}                label = i18n("%1<br>Check change entry %2 of %3").arg(olabel).arg(i).arg(m_Data->m_OldHistory[j].changedPaths.count());                m_Data->progress->setLabel(label);                kapp->processEvents();            }            if (!m_Data->m_OldHistory[j].changedPaths[i].copyFromPath.isEmpty()) {                long r = m_Data->m_OldHistory[j].changedPaths[i].copyFromRevision;                QString sourcepath = m_Data->m_OldHistory[j].changedPaths[i].copyFromPath;                char a = m_Data->m_OldHistory[j].changedPaths[i].action;                if (m_Data->m_OldHistory[j].changedPaths[i].path.isEmpty()) {                    kdDebug()<<"Empty entry! rev " << j << " source " << sourcepath << endl;                    continue;                }                if (a=='R') {                    m_Data->m_OldHistory[j].changedPaths[i].action=0;                } else if (a=='A'){                    a=INTERNALCOPY;                    for (unsigned z = 0;z<m_Data->m_OldHistory[j].changedPaths.count();++z) {                        if (m_Data->m_OldHistory[j].changedPaths[z].action=='D'                            && isParent(m_Data->m_OldHistory[j].changedPaths[z].path,sourcepath) ) {                            a=INTERNALRENAME;                            m_Data->m_OldHistory[j].changedPaths[z].action=0;                            break;                        }                    }                    m_Data->m_History[r].addCopyTo(sourcepath,m_Data->m_OldHistory[j].changedPaths[i].path,j,a,r);                    m_Data->m_OldHistory[j].changedPaths[i].action=0;                } else {                    kdDebug()<<"Action with source path but wrong action \""<<a<<"\" found!"<<endl;                }            }        }    }    kdDebug()<<"Stage two done"<<endl;    if (cancel==true) {        return false;    }    m_Data->progress->setLabel(olabel);    for (long j=m_Data->max_rev;j>=m_Data->min_rev;--j) {        m_Data->progress->progressBar()->setProgress(m_Data->max_rev-j);        kapp->processEvents();        if (m_Data->progress->wasCancelled()) {            cancel=true;            break;        }        for (unsigned i = 0; i<m_Data->m_OldHistory[j].changedPaths.count();++i) {            if (m_Data->m_OldHistory[j].changedPaths[i].action==0) {                continue;            }            if (i>0 && i%100==0) {                if (m_Data->progress->wasCancelled()) {                    cancel=true;                    break;                }                label = i18n("%1<br>Check change entry %2 of %3").arg(olabel).arg(i).arg(m_Data->m_OldHistory[j].changedPaths.count());                m_Data->progress->setLabel(label);                kapp->processEvents();            }            m_Data->m_History[j].addCopyTo(m_Data->m_OldHistory[j].changedPaths[i].path,QString::null,-1,m_Data->m_OldHistory[j].changedPaths[i].action);        }        m_Data->m_History[j].author=m_Data->m_OldHistory[j].author;        m_Data->m_History[j].date=m_Data->m_OldHistory[j].date;        m_Data->m_History[j].revision=m_Data->m_OldHistory[j].revision;        m_Data->m_History[j].message=m_Data->m_OldHistory[j].message;    }    kdDebug()<<"Stage three done"<<endl;    return !cancel;}bool RevisionTree::isParent(const QString&_par,const QString&tar){    if (_par==tar) return true;    QString par = _par+(_par.endsWith("/")?"":"/");    return tar.startsWith(par);}bool RevisionTree::isValid()const{    return m_Valid;}static QString uniqueNodeName(long rev,const QString&path){    QString res = KCodecs::base64Encode(path.local8Bit(),false);    res.replace("\"","_quot_");    res.replace(" ","_space_");    QString n; n.sprintf("%05ld",rev);    res = "\""+n+QString("_%1\"").arg(res);    return res;}bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const QString&_path,long _last){#define REVENTRY m_Data->m_History[j]#define FORWARDENTRY m_Data->m_History[j].changedPaths[i]    QString path = _path;    long lastrev = _last;    /* this is required if an item will modified AND copied at same revision.*/    long trev = -1;#ifdef DEBUG_PARSE    kdDebug()<<"Searching for "<<path<< " at revision " << startrev        << " recursion " << recurse << endl;#endif    bool cancel = false;    for (long j=startrev;j<=m_Data->max_rev;++j) {        if (m_Data->m_stopTick.elapsed()>500) {            m_Data->progress->progressBar()->advance(1);            kapp->processEvents();            m_Data->m_stopTick.restart();        }        if (m_Data->progress->wasCancelled()) {            cancel=true;            break;        }        for (unsigned i=0;i<REVENTRY.changedPaths.count();++i) {            if (!isParent(FORWARDENTRY.path,path)) {                continue;            }            QString n1,n2;            if (isParent(FORWARDENTRY.path,path)) {                bool get_out = false;                if (FORWARDENTRY.path!=path) {#ifdef DEBUG_PARSE                    kdDebug()<<"Parent rename? "<< FORWARDENTRY.path << " -> " << FORWARDENTRY.copyToPath << " -> " << FORWARDENTRY.copyFromPath << endl;#endif                }                if (FORWARDENTRY.action==INTERNALCOPY ||                    FORWARDENTRY.action==INTERNALRENAME ) {                    bool ren = FORWARDENTRY.action==INTERNALRENAME;                    QString tmpPath = path;                    QString recPath;                    if (FORWARDENTRY.copyToPath.length()==0) {                        continue;                    }                    QString r = path.mid(FORWARDENTRY.path.length());                    recPath= FORWARDENTRY.copyToPath;                    recPath+=r;                    n1 = uniqueNodeName(lastrev,tmpPath);                    n2 = uniqueNodeName(FORWARDENTRY.copyToRevision,recPath);                    if (lastrev>0) {                        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n1].targets.append(RevGraphView::targetData(n2,FORWARDENTRY.action));                    }                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].name=recPath;                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].rev = FORWARDENTRY.copyToRevision;                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].Action=FORWARDENTRY.action;                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].Author=m_Data->m_History[FORWARDENTRY.copyToRevision].author;                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].Message=m_Data->m_History[FORWARDENTRY.copyToRevision].message;                    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].Date=helpers::sub2qt::apr_time2qtString(m_Data->m_History[FORWARDENTRY.copyToRevision].date);                    if (ren) {                        lastrev = FORWARDENTRY.copyToRevision;                        /* skip items between */                        j=lastrev;#ifdef DEBUG_PARSE                        kdDebug()<<"Renamed to "<< recPath << " at revision " << FORWARDENTRY.copyToRevision << endl;#endif                        path=recPath;                    } else {#ifdef DEBUG_PARSE                        kdDebug()<<"Copy to "<< recPath << endl;#endif                        if (!bottomUpScan(FORWARDENTRY.copyToRevision,recurse+1,recPath,FORWARDENTRY.copyToRevision)) {                            return false;                        }                    }                } else if (FORWARDENTRY.path==path) {                    switch (FORWARDENTRY.action) {                    case 'A':#ifdef DEBUG_PARSE                        kdDebug()<<"Inserting adding base item"<<endl;#endif                        n1 = uniqueNodeName(j,FORWARDENTRY.path);                        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n1].Action=FORWARDENTRY.action;                        fillItem(j,i,n1,path);                        lastrev=j;                    break;                    case 'M':                    case 'R':#ifdef DEBUG_PARSE                        kdDebug()<<"Item modified at revision "<< j << " recurse " << recurse << endl;#endif                        n1 = uniqueNodeName(j,FORWARDENTRY.path);                        n2 = uniqueNodeName(lastrev,FORWARDENTRY.path);                        if (lastrev>0) m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].targets.append(RevGraphView::targetData(n1,FORWARDENTRY.action));                        fillItem(j,i,n1,path);                        /* modify of same item (in same recurse) should be only once at a revision                         * so check if lastrev==j must not be done but will cost cpu ticks so I always                         * set trev and lastrev.                         */                        trev = lastrev;                        lastrev = j;                    break;                    case 'D':#ifdef DEBUG_PARSE                        kdDebug()<<"(Sloppy match) Item deleted at revision "<< j << " recurse " << recurse << endl;#endif                        n1 = uniqueNodeName(j,path);                        n2 = uniqueNodeName(lastrev,path);                        if (n1==n2) {                            /* cvs import - copy and deletion at same revision.                             * CVS sucks.                             */                            n1 = uniqueNodeName(j,"D_"+path);                        }                        if (lastrev>0) m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].targets.append(RevGraphView::targetData(n1,FORWARDENTRY.action));                        fillItem(j,i,n1,path);                        lastrev = j;                        get_out= true;                    break;                    default:                    break;                    }                } else {                    switch (FORWARDENTRY.action) {                    case 'D':#ifdef DEBUG_PARSE                        kdDebug()<<"(Exact match) Item deleted at revision "<< j << " recurse " << recurse << endl;#endif                        n1 = uniqueNodeName(j,path);                        n2 = uniqueNodeName(lastrev,path);                        if (n1==n2) {                            /* cvs import - copy and deletion at same revision.                             * CVS sucks.                             */                            n1 = uniqueNodeName(j,"D_"+path);                        }                        if (lastrev>0) m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[n2].targets.append(RevGraphView::targetData(n1,FORWARDENTRY.action));                        fillItem(j,i,n1,path);                        lastrev = j;                        get_out = true;                    break;                    default:                    break;                    }                }                if (get_out) {                    return true;                }            }        }    }    return !cancel;}QWidget*RevisionTree::getView(){    return m_Data->m_TreeDisplay;}void RevisionTree::fillItem(long rev,int pathIndex,const QString&nodeName,const QString&path){    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].name=path;    m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].rev = rev;    if (pathIndex>=0) {        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Action=m_Data->m_History[rev].changedPaths[pathIndex].action;        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Author=m_Data->m_History[rev].author;        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Message=m_Data->m_History[rev].message;        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Date=helpers::sub2qt::apr_time2qtString(m_Data->m_History[rev].date);    } else {        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Action=0;        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Author="";        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Message="";        m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].Date=helpers::sub2qt::apr_time2qtString(0);    }}