kallithea Changeset - 64659280e466

Changeset - 64659280e466

Parent rev.

Child rev.

[Not reviewed]

default

0 4 0

Sean Farley - 11 years ago 2014-07-09 07:35:54
sean.michael.farley@gmail.com

graph: show obsolete changesets with an 'X'

4 files changed with 25 insertions and 2 deletions:

kallithea/lib/graphmod.py

kallithea/lib/vcs/backends/base.py

kallithea/lib/vcs/backends/hg/changeset.py

kallithea/public/js/graph.js

0 comments (0 inline, 0 general)

kallithea/lib/graphmod.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 Modified mercurial DAG graph functions that re-uses VCS structure
 It allows to have a shared codebase for DAG generation for hg and git repos
 """
 nullrev = -1
 def _first_known_ancestors(parentrev_func, minrev, knownrevs, head):
     """
     Walk DAG defined by parentrev_func.
     Return most immediate ancestors of head that are in knownrevs.
     minrev is lower bound on knownrevs.
     """
     pending = set([head])
     seen = set()
     ancestors = set()
     while pending:
         r = pending.pop()
         if r < minrev:
             if r > nullrev: # ignore -1 returned from parentrev_func
                 ancestors.add(-head) # fake unique unknown parent for this rev
         elif r in knownrevs:
             ancestors.add(r)
         elif r not in seen:
             pending.update(parentrev_func(r))
             seen.add(r)
     return ancestors
 def graph_data(repo, revs):
     """Return a DAG with colored edge information for revs
     For each DAG node this function emits tuples::
       ((col, color), [(col, nextcol, color)])
     with the following new elements:
       - Tuple (col, color) with column and color index for the current node
       - A list of tuples indicating the edges between the current node and its
         parents.
     """
     dag = _dagwalker(repo, revs)
     return list(_colored(repo, dag))
 def _dagwalker(repo, revs):
     if not revs:
         return
     if repo.alias == 'hg':
         parentrev_func = repo._repo.changelog.parentrevs
     elif repo.alias == 'git':
         def parentrev_func(rev):
             return [x.revision for x in repo[rev].parents]
     minrev = revs[-1] # assuming sorted reverse
     knownrevs = set(revs)
     acache = {}
     for rev in revs:
         parents = set(parentrev_func(rev)) - set([nullrev])
         dagparents = parents & knownrevs
         # Calculate indirect parents
         for p in parents - dagparents:
             ancestors = acache.get(p)
             if ancestors is None:
                 ancestors = acache[p] = _first_known_ancestors(parentrev_func, minrev, knownrevs, p)
             dagparents.update(ancestors)
         yield (rev, sorted(dagparents))
 def _colored(repo, dag):
     """annotates a DAG with colored edge information
     For each DAG node this function emits tuples::
       ((col, color), [(col, nextcol, color)])
     with the following new elements:
       - Tuple (col, color) with column and color index for the current node
       - A list of tuples indicating the edges between the current node and its
         parents.
     """
     branch_cache = {}
     def branch(rev):
         if rev not in branch_cache:
             branch_cache[rev] = repo[rev].branch
         return branch_cache[rev]
     row = []
     colors = {}
     newcolor = 1
     for (rev, dagparents) in dag:
         # Compute row and nextrow
         if rev not in row:
             row.append(rev)  # new head
             colors[rev] = newcolor
             newcolor += 1
         col = row.index(rev)
         addparents = [p for p in dagparents if p not in row]
         # Add unknown parents to nextrow
         tmprow = row[:]
         tmprow[col:col + 1] = reversed(addparents) # highest revs first (to the right), dead ends last (to the left)
         # Stop looking for non-existing ancestors
         nextrow = []
         for r in tmprow:
             if r > nullrev or r in dagparents:
                 nextrow.append(r)
             else:
                 colors.pop(r)
         # Set colors for the parents
         color = colors.pop(rev)
         if addparents:
             b = branch(rev)
             for p in reversed(addparents):
                 if b and branch(abs(p)) == b:
                     colors[p] = color
                     b = None
                 else:
                     colors[p] = newcolor
                     newcolor += 1
         # Add edges to the graph
         edges = []
         for ecol, ep in enumerate(row):
             if ep in nextrow:
                 edges.append((ecol, nextrow.index(ep), colors[ep]))
             elif ep == rev:
                 for p in dagparents:
                     edges.append((ecol, nextrow.index(p), colors[p]))
         # Yield and move on
         closing = int(repo[rev].closesbranch)
         yield ((col, color), edges, closing)
         obsolete = int(repo[rev].obsolete)
         yield ((col, color), edges, closing, obsolete)
         row = nextrow

kallithea/lib/vcs/backends/base.py

➞

Show inline comments

@@ @@ -478,384 +478,388 @@ class BaseChangeset(object): @@
         Returns Author for given commit
         """
         raise NotImplementedError
     @LazyProperty
     def author_name(self):
         """
         Returns Author name for given commit
         """
         return author_name(self.author)
     @LazyProperty
     def author_email(self):
         """
         Returns Author email address for given commit
         """
         return author_email(self.author)
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at the given ``path``.
         """
         raise NotImplementedError
     def get_file_content(self, path):
         """
         Returns content of the file at the given ``path``.
         """
         raise NotImplementedError
     def get_file_size(self, path):
         """
         Returns size of the file at the given ``path``.
         """
         raise NotImplementedError
     def get_file_changeset(self, path):
         """
         Returns last commit of the file at the given ``path``.
         """
         raise NotImplementedError
     def get_file_history(self, path):
         """
         Returns history of file as reversed list of ``Changeset`` objects for
         which file at given ``path`` has been modified.
         """
         raise NotImplementedError
     def get_nodes(self, path):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of changeset at the given ``path``.
         :raises ``ChangesetError``: if node at the given ``path`` is not
           instance of ``DirNode``
         """
         raise NotImplementedError
     def get_node(self, path):
         """
         Returns ``Node`` object from the given ``path``.
         :raises ``NodeDoesNotExistError``: if there is no node at the given
           ``path``
         """
         raise NotImplementedError
     def fill_archive(self, stream=None, kind='tgz', prefix=None):
         """
         Fills up given stream.
         :param stream: file like object.
         :param kind: one of following: ``zip``, ``tar``, ``tgz``
             or ``tbz2``. Default: ``tgz``.
         :param prefix: name of root directory in archive.
             Default is repository name and changeset's raw_id joined with dash.
             repo-tip.<kind>
         """
         raise NotImplementedError
     def get_chunked_archive(self, **kwargs):
         """
         Returns iterable archive. Tiny wrapper around ``fill_archive`` method.
         :param chunk_size: extra parameter which controls size of returned
             chunks. Default:8k.
         """
         chunk_size = kwargs.pop('chunk_size', 8192)
         stream = kwargs.get('stream')
         self.fill_archive(**kwargs)
         while True:
             data = stream.read(chunk_size)
             if not data:
                 break
             yield data
     @LazyProperty
     def root(self):
         """
         Returns ``RootNode`` object for this changeset.
         """
         return self.get_node('')
     def next(self, branch=None):
         """
         Returns next changeset from current, if branch is gives it will return
         next changeset belonging to this branch
         :param branch: show changesets within the given named branch
         """
         raise NotImplementedError
     def prev(self, branch=None):
         """
         Returns previous changeset from current, if branch is gives it will
         return previous changeset belonging to this branch
         :param branch: show changesets within the given named branch
         """
         raise NotImplementedError
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         raise NotImplementedError
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         raise NotImplementedError
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         raise NotImplementedError
     @LazyProperty
     def size(self):
         """
         Returns total number of bytes from contents of all filenodes.
         """
         return sum((node.size for node in self.get_filenodes_generator()))
     def walk(self, topurl=''):
         """
         Similar to os.walk method. Instead of filesystem it walks through
         changeset starting at given ``topurl``.  Returns generator of tuples
         (topnode, dirnodes, filenodes).
         """
         topnode = self.get_node(topurl)
         yield (topnode, topnode.dirs, topnode.files)
         for dirnode in topnode.dirs:
             for tup in self.walk(dirnode.path):
                 yield tup
     def get_filenodes_generator(self):
         """
         Returns generator that yields *all* file nodes.
         """
         for topnode, dirs, files in self.walk():
             for node in files:
                 yield node
     def as_dict(self):
         """
         Returns dictionary with changeset's attributes and their values.
         """
         data = get_dict_for_attrs(self, ['id', 'raw_id', 'short_id',
             'revision', 'date', 'message'])
         data['author'] = {'name': self.author_name, 'email': self.author_email}
         data['added'] = [node.path for node in self.added]
         data['changed'] = [node.path for node in self.changed]
         data['removed'] = [node.path for node in self.removed]
         return data
     @LazyProperty
     def closesbranch(self):
         return False
     @LazyProperty
     def obsolete(self):
         return False
 class BaseWorkdir(object):
     """
     Working directory representation of single repository.
     :attribute: repository: repository object of working directory
     """
     def __init__(self, repository):
         self.repository = repository
     def get_branch(self):
         """
         Returns name of current branch.
         """
         raise NotImplementedError
     def get_changeset(self):
         """
         Returns current changeset.
         """
         raise NotImplementedError
     def get_added(self):
         """
         Returns list of ``FileNode`` objects marked as *new* in working
         directory.
         """
         raise NotImplementedError
     def get_changed(self):
         """
         Returns list of ``FileNode`` objects *changed* in working directory.
         """
         raise NotImplementedError
     def get_removed(self):
         """
         Returns list of ``RemovedFileNode`` objects marked as *removed* in
         working directory.
         """
         raise NotImplementedError
     def get_untracked(self):
         """
         Returns list of ``FileNode`` objects which are present within working
         directory however are not tracked by repository.
         """
         raise NotImplementedError
     def get_status(self):
         """
         Returns dict with ``added``, ``changed``, ``removed`` and ``untracked``
         lists.
         """
         raise NotImplementedError
     def commit(self, message, **kwargs):
         """
         Commits local (from working directory) changes and returns newly
         created
         ``Changeset``. Updates repository's ``revisions`` list.
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
     def update(self, revision=None):
         """
         Fetches content of the given revision and populates it within working
         directory.
         """
         raise NotImplementedError
     def checkout_branch(self, branch=None):
         """
         Checks out ``branch`` or the backend's default branch.
         Raises ``BranchDoesNotExistError`` if the branch does not exist.
         """
         raise NotImplementedError
 class BaseInMemoryChangeset(object):
     """
     Represents differences between repository's state (most recent head) and
     changes made *in place*.
     **Attributes**
         ``repository``
             repository object for this in-memory-changeset
         ``added``
             list of ``FileNode`` objects marked as *added*
         ``changed``
             list of ``FileNode`` objects marked as *changed*
         ``removed``
             list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
             *removed*
         ``parents``
             list of ``Changeset`` representing parents of in-memory changeset.
             Should always be 2-element sequence.
     """
     def __init__(self, repository):
         self.repository = repository
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
     def add(self, *filenodes):
         """
         Marks given ``FileNode`` objects as *to be committed*.
         :raises ``NodeAlreadyExistsError``: if node with same path exists at
           latest changeset
         :raises ``NodeAlreadyAddedError``: if node with same path is already
           marked as *added*
         """
         # Check if not already marked as *added* first
         for node in filenodes:
             if node.path in (n.path for n in self.added):
                 raise NodeAlreadyAddedError("Such FileNode %s is already "
                     "marked for addition" % node.path)
         for node in filenodes:
             self.added.append(node)
     def change(self, *filenodes):
         """
         Marks given ``FileNode`` objects to be *changed* in next commit.
         :raises ``EmptyRepositoryError``: if there are no changesets yet
         :raises ``NodeAlreadyExistsError``: if node with same path is already
           marked to be *changed*
         :raises ``NodeAlreadyRemovedError``: if node with same path is already
           marked to be *removed*
         :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
           changeset
         :raises ``NodeNotChangedError``: if node hasn't really be changed
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError("Node at %s is already marked "
                     "as removed" % node.path)
         try:
             self.repository.get_changeset()
         except EmptyRepositoryError:
             raise EmptyRepositoryError("Nothing to change - try to *add* new "
                 "nodes rather than changing them")
         for node in filenodes:
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError("Node at '%s' is already "
                     "marked as changed" % node.path)
             self.changed.append(node)
     def remove(self, *filenodes):
         """
         Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
         *removed* in next commit.
         :raises ``NodeAlreadyRemovedError``: if node has been already marked to
           be *removed*
         :raises ``NodeAlreadyChangedError``: if node has been already marked to
           be *changed*
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError("Node is already marked to "
                     "for removal at %s" % node.path)
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError("Node is already marked to "
                     "be changed at %s" % node.path)
             # We only mark node as *removed* - real removal is done by
             # commit method
             self.removed.append(node)
     def reset(self):
         """
         Resets this instance to initial state (cleans ``added``, ``changed``
         and ``removed`` lists).
         """
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
     def get_ipaths(self):

kallithea/lib/vcs/backends/hg/changeset.py

➞

Show inline comments

 import os
 import posixpath
 from kallithea.lib.vcs.conf import settings
 from kallithea.lib.vcs.backends.base import BaseChangeset
 from kallithea.lib.vcs.exceptions import (
     ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError,
     NodeDoesNotExistError, VCSError
+)
 from kallithea.lib.vcs.nodes import (
     AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode,
     NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode
+)
 from kallithea.lib.vcs.utils import safe_str, safe_unicode, date_fromtimestamp
 from kallithea.lib.vcs.utils.lazy import LazyProperty
 from kallithea.lib.vcs.utils.paths import get_dirs_for_path
 from kallithea.lib.vcs.utils.hgcompat import archival, hex
 class MercurialChangeset(BaseChangeset):
     """
     Represents state of the repository at the single revision.
     """
     def __init__(self, repository, revision):
         self.repository = repository
         assert isinstance(revision, basestring), repr(revision)
         self.raw_id = revision
         self._ctx = repository._repo[revision]
         self.revision = self._ctx._rev
         self.nodes = {}
     @LazyProperty
     def tags(self):
         return map(safe_unicode, self._ctx.tags())
     @LazyProperty
     def branch(self):
         return  safe_unicode(self._ctx.branch())
     @LazyProperty
     def closesbranch(self):
         return  self._ctx.closesbranch()
     @LazyProperty
     def obsolete(self):
         return  self._ctx.obsolete()
     @LazyProperty
     def bookmarks(self):
         return map(safe_unicode, self._ctx.bookmarks())
     @LazyProperty
     def message(self):
         return safe_unicode(self._ctx.description())
     @LazyProperty
     def committer(self):
         return safe_unicode(self.author)
     @LazyProperty
     def author(self):
         return safe_unicode(self._ctx.user())
     @LazyProperty
     def date(self):
         return date_fromtimestamp(*self._ctx.date())
     @LazyProperty
     def _timestamp(self):
         return self._ctx.date()[0]
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current changeset
         """
         return self.repository._repo.status(self._ctx.p1().node(),
                                             self._ctx.node())
     @LazyProperty
     def _file_paths(self):
         return list(self._ctx)
     @LazyProperty
     def _dir_paths(self):
         p = list(set(get_dirs_for_path(*self._file_paths)))
         p.insert(0, '')
         return p
     @LazyProperty
     def _paths(self):
         return self._dir_paths + self._file_paths
     @LazyProperty
     def id(self):
         if self.last:
             return u'tip'
         return self.short_id
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
     @LazyProperty
     def parents(self):
         """
         Returns list of parents changesets.
         """
         return [self.repository.get_changeset(parent.rev())
                 for parent in self._ctx.parents() if parent.rev() >= 0]
     @LazyProperty
     def children(self):
         """
         Returns list of children changesets.
         """
         return [self.repository.get_changeset(child.rev())
                 for child in self._ctx.children() if child.rev() >= 0]
     def next(self, branch=None):
         if branch and self.branch != branch:
             raise VCSError('Branch option used on changeset not belonging '
                            'to that branch')
         cs = self
         while True:
             try:
                 next_ = cs.revision + 1
                 next_rev = cs.repository.revisions[next_]
             except IndexError:
                 raise ChangesetDoesNotExistError
             cs = cs.repository.get_changeset(next_rev)
             if not branch or branch == cs.branch:
                 return cs
     def prev(self, branch=None):
         if branch and self.branch != branch:
             raise VCSError('Branch option used on changeset not belonging '
                            'to that branch')
         cs = self
         while True:
             try:
                 prev_ = cs.revision - 1
                 if prev_ < 0:
                     raise IndexError
                 prev_rev = cs.repository.revisions[prev_]
             except IndexError:
                 raise ChangesetDoesNotExistError
             cs = cs.repository.get_changeset(prev_rev)
             if not branch or branch == cs.branch:
                 return cs
     def diff(self, ignore_whitespace=True, context=3):
         return ''.join(self._ctx.diff(git=True,
                                       ignore_whitespace=ignore_whitespace,
                                       context=context))
     def _fix_path(self, path):
         """
         Paths are stored without trailing slash so we need to get rid off it if
         needed. Also mercurial keeps filenodes as str so we need to decode
         from unicode to str
         """
         if path.endswith('/'):
             path = path.rstrip('/')
         return safe_str(path)
     def _get_kind(self, path):
         path = self._fix_path(path)
         if path in self._file_paths:
             return NodeKind.FILE
         elif path in self._dir_paths:
             return NodeKind.DIR
         else:
             raise ChangesetError("Node does not exist at the given path '%s'"
                 % (path))
     def _get_filectx(self, path):
         path = self._fix_path(path)
         if self._get_kind(path) != NodeKind.FILE:
             raise ChangesetError("File does not exist for revision %s at "
                 " '%s'" % (self.raw_id, path))
         return self._ctx.filectx(path)
     def _extract_submodules(self):
         """
         returns a dictionary with submodule information from substate file
         of hg repository
         """
         return self._ctx.substate
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at the given ``path``.
         """
         fctx = self._get_filectx(path)
         if 'x' in fctx.flags():
             return 0100755
         else:
             return 0100644
     def get_file_content(self, path):
         """
         Returns content of the file at given ``path``.
         """
         fctx = self._get_filectx(path)
         return fctx.data()
     def get_file_size(self, path):
         """
         Returns size of the file at given ``path``.
         """
         fctx = self._get_filectx(path)
         return fctx.size()
     def get_file_changeset(self, path):
         """
         Returns last commit of the file at the given ``path``.
         """
         return self.get_file_history(path, limit=1)[0]
     def get_file_history(self, path, limit=None):
         """
         Returns history of file as reversed list of ``Changeset`` objects for
         which file at given ``path`` has been modified.
         """
         fctx = self._get_filectx(path)
         hist = []
         cnt = 0
         for cs in reversed([x for x in fctx.filelog()]):
             cnt += 1
             hist.append(hex(fctx.filectx(cs).node()))
             if limit and cnt == limit:
                 break
         return [self.repository.get_changeset(node) for node in hist]

kallithea/public/js/graph.js

➞

Show inline comments

 // branch_renderer.js - Rendering of branch DAGs on the client side
 //
 // Copyright 2010 Marcin Kuzminski <marcin AT python-works DOT com>
 // Copyright 2008 Jesper Noehr <jesper AT noehr DOT org>
 // Copyright 2008 Dirkjan Ochtman <dirkjan AT ochtman DOT nl>
 // Copyright 2006 Alexander Schremmer <alex AT alexanderweb DOT de>
 //
 // derived from code written by Scott James Remnant <scott@ubuntu.com>
 // Copyright 2005 Canonical Ltd.
 //
 // This software may be used and distributed according to the terms
 // of the GNU General Public License, incorporated herein by reference.
 var colors = [
 	[ 1.0, 0.0, 0.0 ],
 	[ 1.0, 1.0, 0.0 ],
 	[ 0.0, 1.0, 0.0 ],
 	[ 0.0, 1.0, 1.0 ],
 	[ 0.0, 0.0, 1.0 ],
 	[ 1.0, 0.0, 1.0 ],
 	[ 1.0, 1.0, 0.0 ],
 	[ 0.0, 0.0, 0.0 ]
 ];
 function BranchRenderer(canvas_id, content_id, row_id_prefix) {
 	// canvas_id is canvas to render into
 	// content_id's height is applied to canvas
 	// row_id_prefix is prefix that is applied to get row id's
 	this.canvas = document.getElementById(canvas_id);
 	var content = document.getElementById(content_id);
 	if (!document.createElement("canvas").getContext)
 		this.canvas = window.G_vmlCanvasManager.initElement(this.canvas);
 	if (!this.canvas) { // canvas creation did for some reason fail - fail silently
 		this.render = function(data,canvasWidth) {};
 		return;
+	}
 	this.ctx = this.canvas.getContext('2d');
 	this.ctx.strokeStyle = 'rgb(0, 0, 0)';
 	this.ctx.fillStyle = 'rgb(0, 0, 0)';
 	this.cur = [0, 0];
 	this.line_width = 2.0;
 	this.dot_radius = 3.5;
 	this.close_x = 1.5 * this.dot_radius;
 	this.close_y = 0.5 * this.dot_radius;
 	this.calcColor = function(color, bg, fg) {
 		color %= colors.length;
 		var red = (colors[color][0] * fg) || bg;
 		var green = (colors[color][1] * fg) || bg;
 		var blue = (colors[color][2] * fg) || bg;
 		red = Math.round(red * 255);
 		green = Math.round(green * 255);
 		blue = Math.round(blue * 255);
 		var s = 'rgb(' + red + ', ' + green + ', ' + blue + ')';
 		return s;
+	}
 	this.setColor = function(color, bg, fg) {
 		var s = this.calcColor(color, bg, fg);
 		this.ctx.strokeStyle = s;
 		this.ctx.fillStyle = s;
+	}
 	this.render = function(data,canvasWidth) {
 		var idx = 1;
 		this.canvas.setAttribute('width',canvasWidth);
 		this.canvas.setAttribute('height',content.clientHeight);
 		// HiDPI version needs to be scaled by 2x then halved via css
 		// Note: Firefox on OS X fails scaling if the canvas height is more than 32k
 		if (window.devicePixelRatio && content.clientHeight * window.devicePixelRatio < 32768) {
 			this.canvas.setAttribute('width', canvasWidth * window.devicePixelRatio);
 			this.canvas.setAttribute('height', content.clientHeight * window.devicePixelRatio);
 			this.canvas.style.width = canvasWidth + "px";
 			this.canvas.style.height = content.clientHeight + "px";
 			this.ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
+		}
 		var lineCount = 1;
 		for (var i=0;i<data.length;i++) {
 			var in_l = data[i][1];
 			for (var j in in_l) {
 				var m = in_l[j][0];
 				if (m > lineCount)
 					lineCount = m;
+			}
+		}
 		var edge_pad = this.dot_radius + 2;
 		var box_size = Math.min(18, (canvasWidth - edge_pad * 2) / lineCount);
 		var base_x = canvasWidth - edge_pad;
 		for (var i=0; i < data.length; ++i) {
 			var row = document.getElementById(row_id_prefix+idx);
 			if (row == null) {
 				console.log("error: row "+row_id_prefix+idx+" not found");
 				continue;
+			}
 			var next = document.getElementById(row_id_prefix+(idx+1));
 			var extra = 0;
 			cur = data[i];
 			node = cur[0];
 			in_l = cur[1];
 			closing = cur[2];
 			obsolete_node = cur[3];
 			var rowY = row.offsetTop + row.offsetHeight/2;
 			var nextY = (next == null) ? rowY + row.offsetHeight/2 : next.offsetTop + next.offsetHeight/2;
 			for (var j in in_l) {
 				line = in_l[j];
 				start = line[0];
 				end = line[1];
 				color = line[2];
 				x = Math.floor(base_x - box_size * start);
 				// figure out if this is a dead-end;
 				// we want to fade away this line
 				var dead_end = true;
 				if (next != null) {
 					nextdata = data[i+1];
 					next_l = nextdata[1];
 					for (var k=0; k < next_l.length; ++k) {
 						if (next_l[k][0] == end) {
 							dead_end = false;
 							break;
+						}
+					}
 					if (nextdata[0][0] == end) // this is a root - not a dead end
 						dead_end = false;
+				}
 				if (dead_end) {
 					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);
 					gradient.addColorStop(0,this.calcColor(color, 0.0, 0.65));
 					gradient.addColorStop(1,this.calcColor(color, 1.0, 0.0));
 					this.ctx.strokeStyle = gradient;
 					this.ctx.fillStyle = gradient;
+				}
 				// if this is a merge of differently
 				// colored line, make it a gradient towards
 				// the merged color
 				else if (color != node[1] && start == node[0])
+				{
 					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);
 					gradient.addColorStop(0,this.calcColor(node[1], 0.0, 0.65));
 					gradient.addColorStop(1,this.calcColor(color, 0.0, 0.65));
 					this.ctx.strokeStyle = gradient;
 					this.ctx.fillStyle = gradient;
+				}
 				else
+				{
 					this.setColor(color, 0.0, 0.65);
+				}
 				this.ctx.lineWidth=this.line_width;
 				this.ctx.beginPath();
 				this.ctx.moveTo(x, rowY);
 				if (start == end)
+				{
 					this.ctx.lineTo(x,nextY+extra,3);
+				}
 				else
+				{
 					var x2 = Math.floor(base_x - box_size * end);
 					var ymid = (rowY+nextY) / 2;
 					this.ctx.bezierCurveTo (x,ymid,x2,ymid,x2,nextY);
+				}
 				this.ctx.stroke();
+			}
 			column = node[0];
 			color = node[1];
 			x = Math.floor(base_x - box_size * column);
 			this.setColor(color, 0.25, 0.75);
 			r = this.dot_radius
 			if (obsolete_node)
+			{
 				this.ctx.beginPath();
 				this.ctx.moveTo(x - this.close_x, rowY - this.close_y - 3);
 				this.ctx.lineTo(x - this.close_x + 2*this.close_x, rowY - this.close_y + 4*this.close_y - 1);
 				this.ctx.moveTo(x - this.close_x, rowY - this.close_y + 4*this.close_y - 1);
 				this.ctx.lineTo(x - this.close_x + 2*this.close_x, rowY - this.close_y - 3);
 				this.ctx.stroke();
 				r -= 0.5
+			}
 			if (closing)
+			{
 				this.ctx.fillRect(x - this.close_x, rowY - this.close_y, 2*this.close_x, 2*this.close_y);
+			}
 			else
+			{
 				this.ctx.beginPath();
-				this.ctx.arc(x, rowY, this.dot_radius, 0, Math.PI * 2, true);
+				this.ctx.arc(x, rowY, r, 0, Math.PI * 2, true);
 				this.ctx.fill();
+			}
 			idx++;
+		}
+	}
+}

0 comments (0 inline, 0 general)