from xpcom import components, COMException, nsError
from xpcom.server import WrapObject, UnwrapObject

import sys, os, re, types
from koTreeView import TreeView
import koToolbox2
import uriparse

import logging

log = logging.getLogger("ProjectTreeView")
#log.setLevel(logging.DEBUG)

# some constants used for live folders
_rebuildDirFlags = \
    components.interfaces.koIFileNotificationService.FS_FILE_CREATED | \
    components.interfaces.koIFileNotificationService.FS_FILE_DELETED | \
    components.interfaces.koIFileNotificationService.FS_UNKNOWN
_rebuildParentFlags = \
    components.interfaces.koIFileNotificationService.FS_DIR_CREATED | \
    components.interfaces.koIFileNotificationService.FS_DIR_DELETED
_createdFlags = \
    components.interfaces.koIFileNotificationService.FS_FILE_CREATED | \
    components.interfaces.koIFileNotificationService.FS_DIR_CREATED
_deletedFlags = \
    components.interfaces.koIFileNotificationService.FS_FILE_DELETED | \
    components.interfaces.koIFileNotificationService.FS_DIR_DELETED
_rebuildFlags = _rebuildDirFlags | _rebuildParentFlags
_notificationsToReceive = _rebuildFlags | \
    components.interfaces.koIFileNotificationService.FS_FILE_MODIFIED
_g_suffix = koToolbox2.PROJECT_FILE_EXTENSION

class _Node(object):
    uri = None
    path = None
    def __init__(self, part, level, project):
        self.part = part
        if part is not None:
            # Store the path and url - saves having to get the part's koIFile.
            self.uri = part.url
            self.path = uriparse.URIToPath(self.uri)
        self.level = level
        self.project = project
        self.isContainer = False

class _ContainerNode(_Node):
    def __init__(self, part, level, project):
        _Node.__init__(self, part, level, project)
        self.isContainer = True
        self.isOpen = False

class _ProjectNode(_ContainerNode):
    pass

class _UnopenedProjectNode(_Node):
    pass

class _GroupNode(_ContainerNode):
    def __init__(self, part, level, project):
        _ContainerNode.__init__(self, part, level, project)
        self.file = None

class _FolderNode(_Node):
    pass    

class _RemoteFolderNode(_Node):
    pass

class _FileNode(_Node):
    pass

class _RemoteFileNode(_Node):
    pass

def _compareNodeClassCheck(a, b):
    """Make sure that the true projects always appear before the
    MRU unopened projects
    """
    return cmp(a[0], b[0])

def _compareNodeValue(a, b, field):
    aval = a[2].getFieldValue(field)
    bval = b[2].getFieldValue(field)
    if isinstance(aval, types.StringTypes):
        return cmp(aval.lower(), bval.lower())
    return cmp(aval, bval)

def compareNodeFolder(a, b, field, sortDir):
    # Each field comes in as a tuple with values
    # 0: project, 1: unopened project
    # 1: classtype for rebuilding the node
    # 2: part
    res = _compareNodeClassCheck(a, b)
    if res:
        return res
    a2 = a[2]
    b2 = b[2]
    a_c = hasattr(a2, 'children')
    b_c = hasattr(b2, 'children')
    if a_c and not b_c:
        return -1
    elif b_c and not a_c:
        return 1
    return _compareNodeValue(a,b,field) * sortDir

def compareNode(a, b, field):
    res = _compareNodeClassCheck(a, b)
    if res:
        return res
    return _compareNodeValue(a, b, field)

class KPFTreeView(TreeView):
    _com_interfaces_ = [components.interfaces.nsIObserver,
                        components.interfaces.koIKPFTreeView,
                        components.interfaces.nsITreeView,
                        components.interfaces.koIFileNotificationObserver,
                        components.interfaces.nsISupportsWeakReference]
    _reg_clsid_ = "{216F0F44-D15B-11DA-8CBD-000D935D3368}"
    _reg_contractid_ = "@activestate.com/koKPFTreeView;1"
    _reg_desc_ = "Komodo KPF Tree View"
        
    def __init__(self, debug=None):
        TreeView.__init__(self, debug=0)
        self._rows = []
        
        # Mapping of node "scoped-name" to a boolean indicating if that
        # node is open (or should be) in the Code Browser.
        self._nodeIsOpen = {}
        self._sortedBy = 'name'
        self._sortDir = 0

        self._tree = None
        self.statusObserver = None
        #self.log = logging.getLogger("ProjectTreeView")
        #self.log.setLevel(logging.DEBUG)
        self._observerSvc = components.classes["@mozilla.org/observer-service;1"].\
            getService(components.interfaces.nsIObserverService)
        self._observerSvc.addObserver(self, "file_status",True) # weakref

    def initialize(self):
        self.atomService = components.classes["@mozilla.org/atom-service;1"].\
                                getService(components.interfaces.nsIAtomService)
        self._prefs = components.classes["@activestate.com/koPrefService;1"].\
            getService(components.interfaces.koIPrefService).prefs
        self._observerSvc = components.classes["@mozilla.org/observer-service;1"].\
            getService(components.interfaces.nsIObserverService)

        # XXX if we ever get more than one project viewer, this will be an issue
        self._partSvc = components.classes["@activestate.com/koPartService;1"]\
            .getService(components.interfaces.koIPartService)
        self._observerSvc.addObserver(self, "file_status", True) # weakref
        self.notificationSvc = components.classes["@activestate.com/koFileNotificationService;1"].\
                                    getService(components.interfaces.koIFileNotificationService)
        try:
            self._placePrefs = self._prefs.getPref("places")
            self._placePrefs.prefObserverService.addObserverForTopics(self,
                             ["showProjectPath",
                              "showProjectPathExtension"],
                                                                      True)
            self._showProjectPath = self._placePrefs.getBoolean('showProjectPath', False)
            self._showProjectPathExtension = self._placePrefs.getBoolean('showProjectPathExtension', False)
        except:
            self._placePrefs = None

    def terminate(self):
        if self._placePrefs:
            self._placePrefs.prefObserverService.removeObserverForTopics(self,
                                 ["showProjectPath",
                                  "showProjectPathExtension"])
        
    def observe(self, subject, topic, data):
        #TODO: When a watched file/folder no longer exists, paint it red.
        if not self._tree:
            # No tree, Komodo is likely shutting down.
            return

        if topic == "file_status":
            try:
                # find the row for the file and invalidate it
                files = data.split("\n")
                invalidRows = [i for (i,row) in enumerate(self._rows) if row.uri in files]
                for row in invalidRows:
                    thisRow = self._rows[row]
                    try:
                        del thisRow.properties
                    except AttributeError:
                        pass
                if invalidRows:
                    self._tree.beginUpdateBatch()
                    map(self._tree.invalidateRow, invalidRows)
                    self._tree.endUpdateBatch()
            except:
                log.exception("Failed on file_status")
        elif topic == "showProjectPath":
            self._showProjectPath = self._placePrefs.getBooleanPref('showProjectPath')
            self._tree.invalidate()
        elif topic == "showProjectPathExtension":
            self._showProjectPathExtension = self._placePrefs.getBoolean('showProjectPathExtension', False)
            self._tree.invalidate()
        

    # nsIFileNotificationObserver
    # we want to receive notifications for any live folders in our view
    # the addition of observers will occur during generateRows
    def fileNotification(self, uri, flags):
        #TODO: When a watched file/folder no longer exists, paint it red.
        #print "got notification [%s] flags %d"%(uri,flags)

        if not self._tree:
            # No tree, Komodo is likely shutting down.
            return

        changed = components.classes["@activestate.com/koFileEx;1"].\
                createInstance(components.interfaces.koIFileEx)
        changed.URI = uri
        matching_parts = []
        #print "   path is [%r] dirname [%r]"%(changed.path, changed.dirName)

        if flags & _rebuildFlags:
            log.debug("received fileNotification flags: %r, path: %r", flags,
                      changed.path);
            for row in self._rows:
                part = row["node"]
                if hasattr(part,'get_liveDirectory'):
                    path = part.get_liveDirectory()
                else:
                    if not hasattr(row, "file"):
                        # Item has not yet been lazily loaded, so we don't
                        # need to compare this item.
                        continue
                    file = row.file
                    if not file:
                        continue
                    path = file.path
                if not path:
                    continue
                #print "row is: %s" % (file.path)
                if flags & _createdFlags and path == changed.dirName or \
                   path == changed.path:
                    matching_parts.append((part, path))
            if not matching_parts:
                return
            if flags & _createdFlags:
                for part, path in matching_parts:
                    if path == changed.dirName:
                        #print "Found parent, refreshing it now"
                        #print "Before:", part.getChildren()
                        part.needrefresh = 1
                        self.refresh(part)
                        #print "After:", part.getChildren()
            elif flags & _rebuildDirFlags:
                for part, path in matching_parts:
                    while part and not hasattr(part, "refreshChildren"):
                        part = part._parent
                    if part:
                        part.needrefresh = 1
                        self.refresh(part)
            elif path == changed.path:
                for part, path in matching_parts:
                    # file or dir deleted
                    #print "   compare [%r]==[%r]"%(file.path,changed.path)
                    parent = part._parent
                    parent.removeChild(part)
                    self.refresh(parent)
        else:
            # this is a modification change, just invalidate rows
            self._tree.invalidate()

    def addProject(self, kpf):
        unwrapped_kpf = self._addProjectPrologue(kpf)
        newProjectIndex = len(self._rows)
        self._rows.append(_ProjectNode(unwrapped_kpf, 0, unwrapped_kpf))
        self._tree.rowCountChanged(newProjectIndex, 1)
        self._addProjectEpilogue(unwrapped_kpf, newProjectIndex)

    def addProjectAtPosition(self, kpf, newProjectIndex):
        unwrapped_kpf = self._addProjectPrologue(kpf)
        self._rows.insert(newProjectIndex, _ProjectNode(unwrapped_kpf, 0, unwrapped_kpf))
        self._tree.rowCountChanged(newProjectIndex, 1)
        self._addProjectEpilogue(unwrapped_kpf, newProjectIndex)

    def moveProjectToEnd(self, project_tuple):
        _, kpfClass, kpf = project_tuple
        self._rows.append(kpfClass(kpf, 0, kpf))
        self._addProjectEpilogue(kpf, len(self._rows) - 1)
        
    def _addProjectPrologue(self, kpf):
        self._partSvc.addProject(kpf)
        unwrapped_kpf = UnwrapObject(kpf)
        self.restorePrefs(unwrapped_kpf)
        self._partSvc.currentProject = unwrapped_kpf
        url = kpf.url
        # If the project is being added while restoring the view state,
        # it's possible that this project is already in the tree as
        # an unopened project in single-project view mode.
        # Ref bug 92356
        for i, row in enumerate(self._rows):
            if row.uri == url:
                del self._rows[i]
                self._tree.rowCountChanged(i, 1)
                break
        return unwrapped_kpf

    def _addProjectEpilogue(self, kpf, newProjectIndex):
        if kpf.id not in self._nodeIsOpen:
            self._nodeIsOpen[kpf.id] = False
        elif (self._nodeIsOpen[kpf.id]
              and not self.isContainerOpen(newProjectIndex)
              and not self.isContainerEmpty(newProjectIndex)):
            self.toggleOpenState(newProjectIndex)

    def addUnopenedProject(self, kpf):
        newProjectIndex = len(self._rows)
        unwrapped_kpf = UnwrapObject(kpf)
        self._rows.append(_UnopenedProjectNode(unwrapped_kpf, 0, unwrapped_kpf))
        self._tree.rowCountChanged(newProjectIndex, 1)

    def addUnopenedProjectAtPosition(self, kpf, newProjectIndex):
        unwrapped_kpf = UnwrapObject(kpf)
        self._rows.insert(newProjectIndex, _UnopenedProjectNode(unwrapped_kpf, 0, unwrapped_kpf))
        self._tree.rowCountChanged(newProjectIndex, 1)
    
    def removeProject(self, kpfWrapped):
        self._partSvc.removeProject(kpfWrapped)
        kpf = UnwrapObject(kpfWrapped)
        self.savePrefs(kpf)
        needNewCurrentProject = kpfWrapped == self.get_currentProject()
        # remove rows for project
        index = self._getIndexByPart(kpf)
        if index == -1:
            log.debug("removeProject: can't find project %s", kpf.get_name())
            return
        sibling = self.getNextSiblingIndex(index)
        if needNewCurrentProject:
            if index == 0:
                # first project becomes active, if there is one
                if sibling < len(self._rows):
                    newCurrentIndex = 0
                else:
                    newCurrentIndex = -1
            else:
                # previous project becomes active
                newCurrentIndex = self._getPrevSiblingIndex(index)#@@@@
        self._rows = self._rows[:index]+self._rows[sibling:]
        if not self._tree:
            # bug 101553: Could happen at shutdown: there is no more project tree
            log.warn("koKPFTreeView.p.py: removeProject: there is no self._tree")
            return
        self._tree.rowCountChanged(index, (index - sibling))

        if needNewCurrentProject:
            self._tree.beginUpdateBatch()
            try:
                self._tree.invalidateRow(index)
                if newCurrentIndex != -1:
                    self.set_currentProject(self._rows[newCurrentIndex].part)
                    self._tree.invalidateRow(newCurrentIndex)
                else:
                    # closing the only project we have, no current project
                    self.set_currentProject(None)
            finally:
                self._tree.endUpdateBatch()
                    
    def clearTree(self):
        nlen = len(self._rows)
        self._rows = []
        self._tree.rowCountChanged(0, -nlen)

    def restorePrefs(self, kpf):
        prefSvc = components.classes["@activestate.com/koPrefService;1"]\
                            .getService().prefs # global prefs
        if prefSvc.hasStringPref("kpf_open_nodes_%s" % kpf.id):
            nioStr = prefSvc.getStringPref("kpf_open_nodes_%s" % kpf.id)
            try:
                nodeIsOpen = eval(nioStr)
                self._nodeIsOpen.update(nodeIsOpen)
            except SyntaxError, ex:
                pass

    def savePrefs(self, kpf):
        prefSvc = components.classes["@activestate.com/koPrefService;1"]\
                            .getService().prefs # global prefs
        # multi tree, we want JUST the project passed in.  Get all the
        # id's from the project, and then get the matching id's from
        # nodeIsOpen
        kpf = UnwrapObject(kpf)
        nodeIsOpen = {}
        for id in self._nodeIsOpen.keys():
            if kpf.getChildById(id):
                nodeIsOpen[id] = self._nodeIsOpen[id]
        prefSvc.setStringPref("kpf_open_nodes_%s" % kpf.id,
                              repr(nodeIsOpen))

    def get_currentProject(self):
        return self._partSvc.currentProject
    
    def set_currentProject(self, prj):
        self._partSvc.currentProject = prj
        project = UnwrapObject(prj)
        if project is None:
            return
        index = self._getIndexByPart(project)
        if index == -1:
            raise Exception("Add the project to the view before making it the current project")
        # if the project is not already visible, make it so
        firstVisRow = self._tree.getFirstVisibleRow()
        lastVisRow = self._tree.getLastVisibleRow()
        numVisRows = self._tree.getPageLength()
        #print "set_currentProject"
        #print "numVisRows: %d" % (numVisRows)
        #print "firstVisRow: %d" % (firstVisRow)
        #print "lastVisRow: %d" % (lastVisRow)
        # If completely outside the range
        # Or if there is un-utilized (empty) rows shown in the tree
        # Or the index is in the visible range, but the tree contents
        # scroll past the end of the visible range
        nextSibling = self.getNextSiblingIndex(index)
        if (index < firstVisRow
            or index >= lastVisRow
            or (len(self._rows) > numVisRows
                and ((nextSibling - index) > numVisRows
                     or len(self._rows) < (firstVisRow + numVisRows)))):
            scrollToIndex = min(index, len(self._rows) - numVisRows)
            #print "Scrolling to row: %d" % (scrollToIndex)
            self._tree.scrollToRow(scrollToIndex)
            self._tree.invalidateRow(index)

    def _getPrevSiblingIndex(self, index):
        level = self._rows[index].level
        i = index - 1
        while i >= 0 and self._rows[i].level > level:
            i = i - 1
        return i

    def getNextSiblingIndex(self, index):
        level = self._rows[index].level
        rc = len(self._rows)
        i = index + 1
        while i < rc and self._rows[i].level > level:
            i = i + 1
        return i

    def addRow(self, row): #@@@@ replace with addItem(item, row)?
        # add this row into our rows index
        if row.level > 0:
            part = row.part
            index = self._getIndexByPart(part.get_parent())
            # insert this prior to the parents sibling
            sibling = self.getNextSiblingIndex(index)
            self._rows.insert(sibling, row)
        else:
            self._rows.append(row)
            index = len(self._rows) - 1
        return self._rows.index(row)
    
    def invalidate(self):
        if self._tree:
            self._tree.beginUpdateBatch()
            self._tree.invalidate()
            self._tree.endUpdateBatch()

    def refresh(self, part):
        """ return the row that should be selected if that's relevant"""
        changed = 0
        retval = 0
        level = 0
        index = -1
        # firstVisibleRow and firstVisiblePart are used to restore the treeview
        # position to the same place after the refresh is done. Fixes bug:
        # http://bugs.activestate.com/show_bug.cgi?id=71331
        firstVisibleRow = self._tree.getFirstVisibleRow()
        firstVisiblePart = None
        if firstVisibleRow >= 0 and firstVisibleRow < len(self._rows):
            firstVisiblePart = self._rows[firstVisibleRow].part
        # Remember the selection as well
        selectedParts = self.getSelectedItems()

        node = None
        if part:
            part = UnwrapObject(part)
            index = self._getIndexByPart(part)
            if index >= 0 and index < len(self._rows):
                node = self._rows[index].part

        # if we get a part, we just refresh that
        if not node:
            log.debug("No node for part %s", part.name)
            return -1
        
        if self.isContainerOpen(index):
            # bink the parent node so we can see the new children
            self.toggleOpenState(index)
            self.toggleOpenState(index)
            
        # Restore the treeview position back to how it originally was
        if firstVisiblePart:
            index = self._getIndexByPart(firstVisiblePart)
            if index >= 0:
                #print "Scrolling to firstVisiblePart: %d" % (index)
                self._tree.scrollToRow(index)
            elif firstVisibleRow < len(self._rows):
                #print "Scrolling to firstVisibleRow: %d" % (firstVisibleRow)
                self._tree.scrollToRow(firstVisibleRow)
        # Restore the selections
        if selectedParts:
            self.selectParts(selectedParts)

        return retval

    def removeItems(self, parts):
        self._tree.beginUpdateBatch()
        try:
            for part in parts:
                index = self.getIndexByPart(part)
                if index != -1:
                    node = self._rows[index]
                    if self.isContainerOpen(index):
                        nextSiblingIndex = self.getNextSiblingIndex(index)
                    else:
                        nextSiblingIndex = index + 1
                    if index == len(self._rows) - 1:
                        pivot = index - 1
                    else:
                        pivot = index
                    self._rows = self._rows[:index] + self._rows[nextSiblingIndex:]
                    self._tree.rowCountChanged(pivot, index - nextSiblingIndex)
        finally:
            self._tree.endUpdateBatch()

    def showChild(self, parentPart, childPart):
        index = self.getIndexByPart(parentPart)
        if index == -1:
            log.error("Can't find parent %s in tree", parentPart.name)
            return
        self.toggleOpenState(index)
        if not self.isContainerOpen(index):
            self.toggleOpenState(index)
        index = self.getIndexByPart(childPart)
        if index == -1:
            log.error("Can't find child %s in tree", childPart.name)
            return
        self._tree.ensureRowIsVisible(index)
        self.selection.select(index)

    def getSelectedItems(self, rootsOnly=False):
        # return the selected koIParts
        if not self._rows:
            return []
        if self.selection.single:
            # deselect all other selections except the current one
            self.selection.select(self.selection.currentIndex)
            return [self._rows[self.selection.currentIndex].part]
        selectedIndices = self.getSelectedIndices(rootsOnly)
        return [self._rows[i].part for i in selectedIndices]
    
    def getSelectedItem(self):
        try:
            return self._rows[self.selection.currentIndex].part
        except IndexError, e:
            return None

    def _getIndexByPart(self, part):
        nodes = [row.part for row in self._rows]
        try:
            return nodes.index(part)
        except ValueError, e:
            return -1
        ids = [row.part.id for row in self._rows]
        try:
            return ids.index(part.id)
        except ValueError, e:
            return -1

    def getIndexByPart(self, part):
        return self._getIndexByPart(UnwrapObject(part))

    def getRowItem(self, index):
        if index >= 0 and index < len(self._rows):
            return self._rows[index].part
        return None

    def getRowItemByURI(self, uri):
        for row in self._rows:
            node = row.part
            try:
                if node.url == uri:
                    return node
            except AttributeError:
                pass
    
    def selectPart(self, part):
        index = self.getIndexByPart(part)
        self.selection.select(index)

    def selectParts(self, parts):
        # Clear the current selection.
        self.selection.clearSelection()
        indices = [ self._getIndexByPart(part) for part in parts ]
        indices.sort()
        index = 0
        i = 0
        while i < len(indices):
            index = indices[i]
            i += 1
            if index < 0:
                # Part has been removed.
                continue
            to_index = index
            # Use the largest range possible for the selection.
            while i < len(indices):
                if indices[i] != to_index + 1:
                    break
                to_index += 1
                i += 1
            # Ranged select call, True means to append to the current selection
            self.selection.rangedSelect(index, to_index, True)

    def sortBy(self, key, direction):
        changed = 0

        # get a current node that we can scroll to after sorting
        selectedNode = None
        if self._rows:
            selected = self.selection.currentIndex
            if selected < 0:
                selected = self._tree.getFirstVisibleRow()
            if 0 <= selected < len(self._rows):
                selectedNode = self._rows[selected]

        if self._sortedBy != key or self._sortDir != direction:
            self._sortedBy = key
            self._sortDir = direction

    def get_sortDirection(self):
        return self._sortDir

    def sortRows(self):
        if self._sortDir == 0:
            # There is no "natural order" in v6.1+
            return
        # projects = [UnwrapObject(x) for x in self._partSvc.getProjects()]
        opened_projects = [(0, _ProjectNode, x.part) for x in self._rows
                           if x.part.type == 'project']
        unopened_projects = [(1, _UnopenedProjectNode, x.part) for x in self._rows
                           if x.part.type == 'unopened_project']
        projects = opened_projects + unopened_projects
        self._sortNodes(projects, self._sortedBy, self._sortDir, force=True)
        olen = len(self._rows)
        self._rows = []
        self._tree.beginUpdateBatch()
        try:
            for p in projects:
                self.moveProjectToEnd(p)
        finally:
            self._tree.endUpdateBatch()
        nlen = len(self._rows)
        self._tree.rowCountChanged(nlen - olen, 0)
        
    def _sortNodes(self, nodes, sortBy, sortDir, force=False):
        if force or self._sortedBy != sortBy or self._sortDir != sortDir:
            log.debug("KPFTree::_sortNodes()")
            if sortDir != 0:
                nodes.sort(lambda a,b: compareNodeFolder(a, b, sortBy, sortDir))
            else:
                nodes.sort(lambda a,b: compareNode(a, b, sortBy))
            self._sortDir = sortDir # cache sort order
            self._sortedBy = sortBy # cache sort order
        else:
            log.debug("KPFTree::_sortNodes:: already sorted")


    _nodeTypeName_from_partTypeName = { 'part' : _Node,
                                        'file' : _FileNode,
                                        'folder' : _GroupNode,
                                        'livefolder': _FolderNode,
                                        'project': _ProjectNode,
                                        }
    def makeRowsFromParts(self, children, level, project):
        """
        @param children: array of koPart
        @returns list of _Node
        """
        nodeList = [self._nodeTypeName_from_partTypeName[child.type](child, level + 1, project)
                  for child in children]
        return sorted(nodeList, key=lambda row: row.part.get_name().lower())
        
    # nsITreeView
    def isSeparator(self, index):
        return 0
    
    def get_rowCount(self):
        return len(self._rows)

    def getRowProperties( self, index, properties=None):
        pass

    def _buildCellProperties(self, row, column):
        prop = []
        prop.append("primaryColumn")
        part = self._rows[row].part
        prop.append(part.type)
        
        if not hasattr(part, 'file'):
            # We hold a reference to the koFile instance, this causes the file
            # status service to check/maintain the file's status information.
            part.file = part.getFile()
        if part.file and not part.file.isLocal:
            prop.append("remote")
        if part.file:
            f = UnwrapObject(part.file)
            # missing, sccOk, sccSync, sccConflict, add, delete, edit,
            # isReadOnly, branch, integrate
            if hasattr(f, 'exists') and not f.exists:
                prop.append("missing")
            else:
                if hasattr(f, 'isReadOnly') and f.isReadOnly:
                    prop.append("isReadOnly")
        return prop
        
    def getCellProperties(self, index, column, properties=None):
        # here we build a list of properties that are used to get the icon
        # for the tree item, text style, etc.  *If getImageSrc returns
        # a url to an icon, the icon matched by properties here will be
        # ignored.  That is convenient since it allows custom icons to work*
        # XXX fixme, optimize
        col_id = self._getFieldName(column)
        if col_id != 'name':
            log.debug("Can't work with column %s, got %s", column.id, col_id)
            return
        plist = []
        if index >= len(self._rows): return
        row = self._rows[index]
        # these are UI properties, such as the twisty, we want to always
        # get them
        if row.isContainer:
            if row.isOpen:
                plist.append("open")
            else:
                plist.append("closed")
            part = row.part
            if part.type == "project" and part.id == getattr(self._partSvc.currentProject, 'id', None):
                plist.append("projectActive")
        if not hasattr(row, 'properties'):
            # these properties rarely change, keep them cached
            row.properties = self._buildCellProperties(index, column)
        plist.extend(row.properties)

        #print "row %d %s : %r"% (index, column.id, plist)

        # Mozilla 22+ does not have a properties argument.
        if properties is None:
            return " ".join(plist)
        for p in plist:
            properties.AppendElement(self.atomService.getAtom(p))

    # in nsITreeColumn col, in nsISupportsArray properties
    def getColumnProperties(self, 
                            column,
                            properties=None):
        # Result: void - None
        # In: param0: wstring
        # In: param1: nsIDOMElement
        # In: param2: nsISupportsArray
        if self.log:
            self.log.debug("getColumnProperties(column=%s, props=%r)",
                           column, properties)
            
    def _getContainerNode(self, index):
        if index >= len(self._rows) or index < 0: return None
        return self._rows[index]

    def isContainer(self, index):
        node = self._getContainerNode(index)
        if node is None: return False
        return node.isContainer

    def isContainerOpen(self, index):
        node = self._getContainerNode(index)
        if node is None: return False
        return node.isContainer and node.isOpen

    def isContainerEmpty( self, index ):
        node = self._getContainerNode(index)
        if node is None: return False
        try:
            return node.isContainer and len(node.part.children) == 0
        except AttributeError:
            #log.debug("isContainerEmpty: node:%d, part:%s",
            #           index, node.part or "<null>")
            return False

    def isSorted( self ):
        # Result: boolean
        return self._sortDir != 0

    def getParentIndex( self, index):
        if index >= len(self._rows) or index < 0: return -1
        i = index - 1
        targetLevel = self._rows[index].level - 1
        if targetLevel < 0:
            return -1
        while i >= 0 and self._rows[i].level > targetLevel:
            i -= 1
        if i == -1:
            log.debug("getParentIndex: couldn't find parent of item %d", index)
        elif self._rows[i].level < targetLevel:
            log.debug("getParentIndex: looking for item at level %d above %d, landed at level %d at item %d",
                      targetLevel, index, self._rows[i].level, i)
        return i

    def hasNextSibling( self, index, afterIndex ):
        if index >= len(self._rows) or index < 0: return 0
        current_level = self._rows[index].level
        for n in self._rows[afterIndex + 1:]:
            n_level = n.level
            if n_level < current_level:
                return 0
            elif n_level == current_level:
                return 1
        return 0

    def getLevel(self, index):
        if index >= len(self._rows) or index < 0: return -1
        return self._rows[index].level

    _name_fields = { 'placesSubpanelProjectNameTreecol_MPV':'name',
                     'placesSubpanelProjectNameTreecol_SPV':'name', }
    def _getFieldName(self, column):
        return self._name_fields.get(column.id, column.id)

    def getImageSrc(self, index, column):
        # see comment in getCellProperties regarding images
        # XXX fixme, optimize
        if index >= len(self._rows) or index < 0: return ""
        name = self._getFieldName(column)
        if name == "name":
            part = self._rows[index].part
            if part._attributes.has_key('icon'):
                #print "getImageSrc row %d [%s]"% (index, part._attributes['icon'])
                return part._attributes['icon']
            else:
                try:
                    return part.get_iconurl() or ""
                except:
                    log.exception("Error trying to get icon")
        return ""

    def getCellValue(self, index, column):
        ####log.debug("getCellValue(%d/%s) => ...", index, column.id)
        if index >= len(self._rows) or index < 0: return
        part = self._rows[index].part
        name = self._getFieldName(column)
        if hasattr(part, name):
            ####log.debug(" => %s", getattr(part, name))
            return getattr(part, name)
        get_name = "get_" + name
        if hasattr(part, get_name):
            ####log.debug(" => %s", getattr(part, get_name)())
            return getattr(part, get_name)()
        ####log.debug(" => %s", "")
        return ""

    def getCellText(self, index, column):
        ####log.debug("getCellText(%d/%s) => ...", index, column.id)
        # XXX fixme, optimize
        if index >= len(self._rows) or index < 0: return
        node = self._rows[index]
        child = node.part
        name = self._getFieldName(column)
        if node.level == 0:
            if self._showProjectPath:
                text = node.path
            else:
                text = child.getFieldValue(name)
            if not self._showProjectPathExtension:
                text = text[:-len(_g_suffix)]
        else:
            text = child.getFieldValue(name)
        #print "field %s text %s" % (name, text)
        if not isinstance(text, basestring):
            if name == 'size':
                if text < 1024:
                    text = "%d bytes" % text
                elif text < 1024*1024:
                    text = "%d KB" % (text/1024)
                else:
                    text = "%d MB" % (text/(1024*1024))
            elif name == 'date':
                import time
                format = self._prefs.getStringPref("defaultDateFormat")
                t = time.localtime(text)
                text = time.strftime(format, t)
            else:
                text = str(text)
        #print "getCellText for index %d col %s is %s" %(index, name, text)
        if name == 'name' and child.type == 'project' and child.get_isDirty():
            text = text+"*"
        ####log.debug("... %s", text)
        return text

    def setTree(self, tree):
        self._tree = tree

    def toggleOpenState(self, index):
        #print "toggle row at index %d"%index
        node = self._rows[index]
        if not node or not node.isContainer:
            log.error("toggleOpenState: index:%d: not a container", index)
            return
        isOpen = node.isOpen
        level = node.level

        # Must recalculate the rows.
        nextSiblingIndex = self.getNextSiblingIndex(index)
        if isOpen:
            # just remove the children from the rows
            #print "removing rows %d to %d" %(index,i)
            self._rows = self._rows[:index + 1] + self._rows[nextSiblingIndex:]
            self._tree.rowCountChanged(index + 1,(index + 1) - nextSiblingIndex)
        else:
            # just get the rows for the node, then insert them into our list
            try:
                children = self.makeRowsFromParts(node.part.children, node.level, node.project)
            except AttributeError, ex:
                msg = ("Error trying to get children for row %d (%s)" %
                       (index, node.part.get_name()))
                if ex.message == "'koProject' object has no attribute 'children'":
                    log.debug("%s", msg)
                              
                else:
                    log.exception("%s", msg)
                children = []
            self._rows = self._rows[:index + 1] + children + self._rows[nextSiblingIndex:]
            self._tree.rowCountChanged(index + 1, len(children))
            for child in children:
                childPart = child.part
                if self._nodeIsOpen.get(childPart.id, False):
                    childIndex = self.getIndexByPart(childPart)
                    if (childIndex != -1
                          and not self.isContainerOpen(childIndex)
                          and not self.isContainerEmpty(childIndex)):
                        self.toggleOpenState(childIndex)
                            
        self._nodeIsOpen[node.part.id] = node.isOpen = not isOpen
        # Ensure the toggle state is correctly redrawn, fixes bug:
        #   http://bugs.activestate.com/show_bug.cgi?id=71942
        self._tree.invalidateRow(index)

        self.selection.currentIndex = index
        self.selection.select(index)
