Merge pull request #99 from macgitver/sc/refsview

Sc/refsview

Author: scunz

History/HistoryBuilder.cpp

@@ -71,14 +71,14 @@ void HistoryBuilder::addBranches(bool includeRemotes)
 
     QStringList sl = mRepo.branchNames(r, true, false);
     foreach (const QString& s, sl) {
-        mWalker.pushRef(r, QLatin1Literal("refs/heads/") % s);
+        mWalker.pushRef(r, QStringLiteral("refs/heads/") % s);
     }
 
     if (includeRemotes) {
         sl = mRepo.branchNames(r, false, true);
 
         foreach (const QString& s, sl) {
-            mWalker.pushRef(r, QLatin1Literal("refs/remotes/") % s);
+            mWalker.pushRef(r, QStringLiteral("refs/remotes/") % s);
         }
     }
 }

History/HistoryDiff.cpp

@@ -52,15 +52,15 @@ HistoryDiff::HistoryDiff()
     mToolbar = new QToolBar;
 
     mDiffTo = new QComboBox;
+    mDiffTo->addItem( trUtf8( "All parents" ), DTT_AllParents );
+    mDiffTo->addItem( trUtf8( "Parent" ), DTT_Parent );
     mDiffTo->addItem( trUtf8( "Workingtree" ), DTT_WT );
     mDiffTo->addItem( trUtf8( "Index" ), DTT_Index );
     mDiffTo->addItem( trUtf8( "Workingtree + Index" ), DTT_WT_and_Index );
     mDiffTo->addItem( trUtf8( "HEAD" ), DTT_HEAD );
     //mDiffTo->addItem( trUtf8( "SHA-1" ), DTT_AnySHA1 );
     mDiffTo->addItem( trUtf8( "Branch" ), DTT_Branch );
     mDiffTo->addItem( trUtf8( "Tag" ), DTT_Tag );
-    mDiffTo->addItem( trUtf8( "All parents" ), DTT_AllParents );
-    mDiffTo->addItem( trUtf8( "Parent" ), DTT_Parent );
 
     mToolbar->addWidget( new QLabel( trUtf8( "Diff to:" ) ) );
     mToolbar->addWidget( mDiffTo );

History/HistoryEntry.h

@@ -61,9 +61,82 @@ struct HistoryInlineRef
     bool        mIsRemote   : 1;
     bool        mIsTag      : 1;
     bool        mIsStash    : 1;
+    bool        mIsDetached : 1;
+
+    bool operator ==(const HistoryInlineRef& other) const
+    {
+        if ( this == &other ) {
+            return true;
+        }
+
+        return  mRefName    == other.mRefName       &&
+                mIsBranch   == other.mIsBranch      &&
+                mIsCurrent  == other.mIsCurrent     &&
+                mIsRemote   == other.mIsRemote      &&
+                mIsTag      == other.mIsTag         &&
+                mIsStash    == other.mIsStash       &&
+                mIsDetached == other.mIsDetached    ;
+    }
+
+    inline bool operator !=(const HistoryInlineRef& other) const {
+        return !( *this == other );
+    }
+
+    inline bool detachedHEAD() const
+    {
+        return mIsDetached && !(mIsTag || mIsBranch || mIsStash);
+    }
+
+    inline bool nameLessThan(const HistoryInlineRef& other) const
+    {
+        return mRefName < other.mRefName;
+    }
+
+    bool operator <(const HistoryInlineRef& other) const
+    {
+        // sort order:
+        // - tag
+        // - detached HEAD
+        // - current branch
+        // - local branch
+        // - remote branch
+        // - stash
+        // - Everything else is sorted by mRefName
+
+        if ( mIsTag ) {
+            // tags have highest priority
+            return other.mIsTag ? nameLessThan(other) : true;
+        }
+
+        if ( detachedHEAD() )
+        {
+            // a detached HEAD comes right after tag ? -> There can only be one!
+            return !other.mIsTag;
+        }
+
+        if ( mIsBranch )
+        {
+            if ( other.mIsTag || other.mIsCurrent || other.detachedHEAD() )
+                return false;
+
+            if ( mIsCurrent ) {
+                // a is the current branch
+                return true;
+            }
+
+            return ( mIsRemote == other.mIsRemote ) ? nameLessThan( other ) : !mIsRemote;
+        }
+
+        if ( mIsStash ) {
+            return other.mIsStash ? nameLessThan( other )
+                                  : !(other.mIsTag || other.mIsBranch || other.detachedHEAD());
+        }
+
+        return !(other.mIsTag || other.mIsBranch || other.mIsStash || other.detachedHEAD()) ? nameLessThan( other ) : false;
+    }
 };
 
-typedef QVector< HistoryInlineRef > HistoryInlineRefs;
+typedef QList< HistoryInlineRef > HistoryInlineRefs;
 
 class HistoryEntry
 {

History/HistoryListDelegate.cpp

@@ -304,7 +304,11 @@ QColor HistoryListDelegate::colorForRefType(const HistoryInlineRef& ref) const
         return QColor::fromHsl(89, 255, 190);
     }
 
-    return QColor( 0xD9D9D9 );
+    if ( ref.mIsStash )
+        return QColor( 0xD9D9D9 );
+
+    // DETACHED REF
+    return QColor( 0xFF5959 );
 }
 
 void HistoryListDelegate::paintMessage( QPainter* p, const QStyleOptionViewItem& opt,