Ticket #11563: bug#11563-patch-4.patch

src/apps/haikudepot/ui/PackageContentsView.cpp

@@ -1 +1 @@
 /*
- * Copyright 2015, TigerKid001.
+ * Copyright 2015, Stephan Aßmus <superstippi@gmx.de>.
+ * Copyright 2015, Sidhant Sharma <tigerkid001@gmail.com>.
  * All rights reserved. Distributed under the terms of the MIT License.
  */
 
 #include "PackageContentsView.h"
+#include "MainWindow.h"
 
 #include <algorithm>
 #include <stdio.h>
@@ -11 +13 @@
 #include <Autolock.h>
 #include <Catalog.h>
 #include <FindDirectory.h>
-#include <MessageFormat.h>
 #include <LayoutBuilder.h>
 #include <LayoutUtils.h>
-#include <OutlineListView.h>
+#include <MessageFormat.h>
+#include <Mime.h>
+#include <NodeInfo.h>
 #include <Path.h>
 #include <ScrollBar.h>
 #include <ScrollView.h>
 #include <StringItem.h>
+#include <StringForSize.h>
 
 #include <package/PackageDefs.h>
 #include <package/hpkg/NoErrorOutput.h>
 #include <package/hpkg/PackageContentHandler.h>
 #include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
 #include <package/hpkg/PackageReader.h>
 
 using namespace BPackageKit;
@@ -39 +44 @@
 #define B_TRANSLATION_CONTEXT "PackageContentsView"
 
 
-//! Layouts the scrollbar so it looks nice with no border and the document
-// window look.
-class CustomScrollView : public BScrollView {
+class PackageEntry : public BPackageEntry {
 public:
-    CustomScrollView(const char* name, BView* target)
-        :
-        BScrollView(name, target, 0, false, true, B_NO_BORDER)
-    {
-    }
+                                PackageEntry(const BPackageEntry* entry, const BString path);
+        virtual             ~PackageEntry();
+        BString             Path() const 
+                                    {return fPath;} 
+private:
+        BString fPath;
+};
 
-    virtual void DoLayout()
-    {
-        BRect innerFrame = Bounds();
-        innerFrame.right -= B_V_SCROLL_BAR_WIDTH + 1;
+// A field type displaying both a bitmap and a string so that the
+// tree display looks nicer (both text and bitmap are indented)
+class BitmapStringField : public BStringField {
+    typedef BStringField Inherited;
+public:
+                                        BitmapStringField(const PackageEntry* entry);
+    virtual                         ~BitmapStringField();
 
-        BView* target = Target();
-        if (target != NULL) {
-            Target()->MoveTo(innerFrame.left, innerFrame.top);
-            Target()->ResizeTo(innerFrame.Width(), innerFrame.Height());
-        }
+            void                        SetBitmap(const BBitmap* bitmap);
+            const BBitmap*  Bitmap() const
+                                        {return NULL/*fIcon*/;}
+private:
+        const BBitmap* fIcon;
+};
 
-        BScrollBar* scrollBar = ScrollBar(B_VERTICAL);
-        if (scrollBar != NULL) {
-            BRect rect = innerFrame;
-            rect.left = rect.right + 1;
-            rect.right = rect.left + B_V_SCROLL_BAR_WIDTH;
-            rect.bottom -= B_H_SCROLL_BAR_HEIGHT;
 
-            scrollBar->MoveTo(rect.left, rect.top);
-            scrollBar->ResizeTo(rect.Width(), rect.Height());
-        }
-    }
-};
+// BColumn for PackageContentsView which knows how to render
+// a BitmapStringField
+class PackageEntryColumn : public BTitledColumn {
+    typedef BTitledColumn Inherited;
+public:
+                                PackageEntryColumn(const char* title,
+                                    float width, float minWidth,
+                                    float maxWidth, uint32 truncateMode,
+                                    alignment align = B_ALIGN_LEFT);
+
+    virtual void                DrawField(BField* field, BRect rect,
+                                    BView* parent);
+    virtual int                 CompareFields(BField* field1, BField* field2);
+    virtual float               GetPreferredWidth(BField* field,
+                                    BView* parent) const;
 
-// #pragma mark - PackageEntryItem
+    virtual bool                AcceptsField(const BField* field) const;
 
+    static  void                InitTextMargin(BView* parent);
 
-class PackageEntryItem : public BStringItem {
+private:
+            uint32              fTruncateMode;
+    static  float               sTextMargin;
+};
+
+
+// BRow for the PartitionListView
+class PackageEntryRow : public BRow {
+    typedef BRow Inherited;
 public:
-    PackageEntryItem(const BPackageEntry* entry, const BString& path)
-        :
-        BStringItem(entry->Name()),
-        fPath(path)
-    {
-        if (fPath.Length() > 0)
-            fPath.Append("/");
-        fPath.Append(entry->Name());
-    }
-    
-    inline const BString& EntryPath() const
-    {
-        return fPath;
-    }
+                                PackageEntryRow(const PackageEntry* entry, 
+                                                    const BBitmap* bitmap =NULL);
+                                PackageEntryRow(BString msg);
+    virtual                     ~PackageEntryRow();
+
+            const PackageEntry* Entry()
+                                    { return fPackageEntry; }
+
+            void                UpdateTitle(const BBitmap* bitmap = NULL);
+            void                UpdateSize();
+            void                UpdatePermissions();
+            void                UpdateLinkTargets();
+            void                SetBitmap(const BBitmap* bitmap);
 
 private:
-    BString fPath;
+            BitmapStringField* fTitle;
+            const PackageEntry*     fPackageEntry;
 };
 
 
-// #pragma mark - PackageContentOutliner
+// #pragma mark - PackageEntry
 
+PackageEntry::PackageEntry(const BPackageEntry* entry, const BString path)
+    :
+    BPackageEntry(*entry),
+    fPath(path)
+{
+        //TODO: Something!
+}
+
+
+PackageEntry::~PackageEntry()
+{
+}
 
-class PackageContentOutliner : public BPackageContentHandler {
+
+// #pragma mark - BitmapStringField
+
+BitmapStringField::BitmapStringField(   const PackageEntry* entry)
+    :
+    Inherited(entry->Name())
+{
+    //SetBitmap(entry); 
+}
+
+
+BitmapStringField::~BitmapStringField()
+{
+}
+
+
+void
+BitmapStringField::SetBitmap(const BBitmap* icon)
+{
+    /*
+    //Get mimetype of package entry and set icon
+    BMimeType mimeType;
+    BNode node(entry->Path().String());
+    BNodeInfo nodeInfo(&node);
+    BBitmap* icon = new BBitmap(BRect(0,0,15,15), B_RGBA32);
+//  char mimeTypeString[B_MIME_TYPE_LENGTH];
+    if (nodeInfo.GetIcon(icon, B_MINI_ICON) != B_OK) {
+            if(mimeType.GetIcon(icon, B_MINI_ICON) != B_OK) {
+                printf("Failed to get icon for %s,%s!", entry->Name(), 
+                                                entry->Path().String());
+                return;
+        }
+        nodeInfo.SetIcon(icon, B_MINI_ICON);    
+    } else
+        mimeType.SetIcon(icon, B_MINI_ICON);
+    */
+    
+    fIcon = icon;
+    // TODO: cause a redraw?
+}
+
+
+// #pragma mark - PackageContentOutliner
+
+class PackageContentOutliner 
+            : public BPackageContentHandler {
 public:
-    PackageContentOutliner(BOutlineListView* listView,
-            const PackageInfo* packageInfo,
-            BLocker& packageLock, PackageInfoRef& packageInfoRef)
+    PackageContentOutliner(const PackageInfo* packageInfo,
+            BLocker& packageLock, PackageInfoRef& packageInfoRef ,
+            BPath packagePath, PackageContentsView* view)
         :
-        fListView(listView),
+        fView(view),
         fLastParentEntry(NULL),
-        fLastParentItem(NULL),
+        fLastParentRow(NULL),
         fLastEntry(NULL),
-        fLastItem(NULL),
-
+        fLastRow(NULL),
         fPackageInfoToPopulate(packageInfo),
         fPackageLock(packageLock),
-        fPackageInfoRef(packageInfoRef)
+        fPackageInfoRef(packageInfoRef),
+        fPackagePath(packagePath)
     {
     }
 
     virtual status_t HandleEntry(BPackageEntry* entry)
     {
-//      printf("HandleEntry(%s/%s)\n",
-//          entry->Parent() != NULL ? entry->Parent()->Name() : "NULL",
-//          entry->Name());
+    /*  printf("\n**HandleEntry(%s/%s)\n",
+            entry->Parent() != NULL ? entry->Parent()->Name() : "NULL",
+            entry->Name());
 
-        if (!fListView->LockLooper())
+    if (!fView->LockLooper())
             return B_ERROR;
 
         // Check if we are still supposed to popuplate the list
         if (fPackageInfoRef.Get() != fPackageInfoToPopulate) {
-//          printf("stopping package content population\n");
-            fListView->UnlockLooper();
+            printf("stopping package content population\n");
+            fView->UnlockLooper();
             return B_ERROR;
         }
 
         BString path;
         const BPackageEntry* parent = entry->Parent();
+        
         while (parent != NULL) {
             if (path.Length() > 0)
                 path.Prepend("/");
             path.Prepend(parent->Name());
             parent = parent->Parent();
         }
-
-        PackageEntryItem* item = new PackageEntryItem(entry, path);
-
-        if (entry->Parent() == NULL) {
-//          printf("  adding root entry\n");
-            fListView->AddItem(item);
+        path.Prepend("/");
+        path.Prepend(fPackagePath.Path());
+        BPath entryPath(path.String());
+        printf("\npath: %s\n",path.String());
+        printf("\\m/%s,\\m/%s\n", fPackagePath.Path(), entryPath.Path());
+        // create the row for this package
+        packageRow = new PackageEntryRow(
+                                        new PackageEntry(entry, path));
+//      BitmapStringField* item = new BitmapStringField(entry);
+
+    if (entry->Parent() == NULL) {
+            // add the row, parent may be NULL (add at top level)
+            fView->AddRow(packageRow);
             fLastParentEntry = NULL;
-            fLastParentItem = NULL;
+            fLastParentRow = NULL;
         } else if (entry->Parent() == fLastEntry) {
-//          printf("  adding to last entry %s\n", fLastEntry->Name());
-            fListView->AddUnder(item, fLastItem);
+            fView->AddRow(packageRow, fLastRow);
             fLastParentEntry = fLastEntry;
-            fLastParentItem = fLastItem;
+            fLastParentRow = fLastRow;
         } else if (entry->Parent() == fLastParentEntry) {
-//          printf("  adding to last parent %s\n", fLastParentEntry->Name());
-            fListView->AddUnder(item, fLastParentItem);
+            fView->AddRow(packageRow, fLastParentRow);
         } else {
             // Not the last parent entry, need to search for the parent
             // among the already added list items.
             bool foundParent = false;
-            for (int32 i = 0; i < fListView->FullListCountItems(); i++) {
-                PackageEntryItem* listItem
-                    = dynamic_cast<PackageEntryItem*>(
-                        fListView->FullListItemAt(i));
-                if (listItem == NULL)
-                    continue;
-                if (listItem->EntryPath() == path) {
-                    fLastParentEntry = entry->Parent();
-                    fLastParentItem = listItem;
-//                  printf("  found parent %s\n", listItem->Text());
-                    fListView->AddUnder(item, listItem);
-                    foundParent = true;
-                    break;
-                }
+            PackageEntryRow* row = (PackageEntryRow*) fView->_FindRow(
+                                                entry->Parent()->Name());
+            if(row == NULL) {
+                foundParent = false;
+            } else {
+                fLastParentEntry = entry->Parent();
+                fLastParentRow = row;
+                fView->AddRow(packageRow, row);
+                foundParent = true;
             }
+            
             if (!foundParent) {
                 // NOTE: Should not happen. Just add this entry at the
                 // root level.
-//              printf("Did not find parent entry for %s (%s)!\n",
-//                  entry->Name(), entry->Parent()->Name());
-                fListView->AddItem(item);
+                printf("Did not find parent entry for %s (%s)!\n",
+                entry->Name(), entry->Parent()->Name());
+                fView->AddRow(packageRow);
                 fLastParentEntry = NULL;
-                fLastParentItem = NULL;
+                fLastParentRow = NULL;
             }
         }
-
+        // make sure the row is initially expanded
+        fView->ExpandOrCollapse(packageRow, true);
         fLastEntry = entry;
-        fLastItem = item;
+        fLastRow = packageRow;
 
-        fListView->UnlockLooper();
-
-        return B_OK;
+    fView->UnlockLooper();*/
+    printf("\n\t\t******HandeEntry*******\n");
+    return B_OK;
     }
 
     virtual status_t HandleEntryAttribute(BPackageEntry* entry,
         BPackageEntryAttribute* attribute)
     {
+        int32 attr = (int32) attribute->Data().InlineData();
+        SharedBitmap shared(attr);
+        fPackageIcon = (BBitmap*) shared.Bitmap(SharedBitmap::SIZE_16);
+        printf("\n\t\t******HandeEntryAttribute*******\n");
+        if(fPackageIcon != NULL)
+            printf("fPackageIcon not null");
+//          return B_ERROR;
         return B_OK;
     }
 
     virtual status_t HandleEntryDone(BPackageEntry* entry)
     {
+        if (!fView->LockLooper())
+            return B_ERROR;
+
+        // Check if we are still supposed to popuplate the list
+        if (fPackageInfoRef.Get() != fPackageInfoToPopulate) {
+            printf("stopping package content population\n");
+            fView->UnlockLooper();
+            return B_ERROR;
+        }
+
+        BString path;
+        const BPackageEntry* parent = entry->Parent();
+        
+        while (parent != NULL) {
+            if (path.Length() > 0)
+                path.Prepend("/");
+            path.Prepend(parent->Name());
+            parent = parent->Parent();
+        }
+        path.Prepend("/");
+        path.Prepend(fPackagePath.Path());
+        BPath entryPath(path.String());
+        printf("\npath: %s\n",path.String());
+        printf("\\m/%s,\\m/%s\n", fPackagePath.Path(), entryPath.Path());
+        // create the row for this package
+        PackageEntryRow* packageRow = new PackageEntryRow(
+                                new PackageEntry(entry, path));
+        if (entry->Parent() == NULL) {
+            // add the row, parent may be NULL (add at top level)
+            fView->AddRow(packageRow);
+            fLastParentEntry = NULL;
+            fLastParentRow = NULL;
+        } else if (entry->Parent() == fLastEntry) {
+            fView->AddRow(packageRow, fLastRow);
+            fLastParentEntry = fLastEntry;
+            fLastParentRow = fLastRow;
+        } else if (entry->Parent() == fLastParentEntry) {
+            fView->AddRow(packageRow, fLastParentRow);
+        } else {
+            // Not the last parent entry, need to search for the parent
+            // among the already added list items.
+            bool foundParent = false;
+            PackageEntryRow* row = (PackageEntryRow*) fView->_FindRow(
+                                                entry->Parent()->Name());
+            if(row == NULL) {
+                foundParent = false;
+            } else {
+                fLastParentEntry = entry->Parent();
+                fLastParentRow = row;
+                fView->AddRow(packageRow, row);
+                foundParent = true;
+            }
+            
+            if (!foundParent) {
+                // NOTE: Should not happen. Just add this entry at the
+                // root level.
+                printf("Did not find parent entry for %s (%s)!\n",
+                entry->Name(), entry->Parent()->Name());
+                fView->AddRow(packageRow);
+                fLastParentEntry = NULL;
+                fLastParentRow = NULL;
+            }
+        }
+        // make sure the row is initially expanded
+        fView->ExpandOrCollapse(packageRow, true);
+        fLastEntry = entry;
+        fLastRow = packageRow;
+
+    fView->UnlockLooper();
+    printf("\n\t\t******HandeEntryDone*******\n");
         return B_OK;
     }
 
@@ -219 +378 @@
     }
     
 private:
-    BOutlineListView*       fListView;
 
+    PackageContentsView* fView;
+    
     const BPackageEntry*    fLastParentEntry;
-    PackageEntryItem*       fLastParentItem;
+    PackageEntryRow*        fLastParentRow;
 
     const BPackageEntry*    fLastEntry;
-    PackageEntryItem*       fLastItem;
+    PackageEntryRow*        fLastRow;
 
     const PackageInfo*      fPackageInfoToPopulate;
     BLocker&                fPackageLock;
-    PackageInfoRef&         fPackageInfoRef;
+    PackageInfoRef          fPackageInfoRef;
+    BPath                   fPackagePath;
+    BBitmap*                fPackageIcon;
 };
 
 
-// #pragma mark - PackageContentView
+// #pragma mark - PackageEntryColumn
+
 
+float PackageEntryColumn::sTextMargin = 0.0;
 
-PackageContentsView::PackageContentsView(const char* name)
+PackageEntryColumn::PackageEntryColumn(const char* title, float width, float minWidth,
+        float maxWidth, uint32 truncateMode, alignment align)
     :
-    BView("package_contents_view", B_WILL_DRAW),
-    fPackageLock("package contents populator lock")
+    Inherited(title, width, minWidth, maxWidth, align),
+    fTruncateMode(truncateMode)
 {
-    fContentListView = new BOutlineListView("content list view", 
-        B_SINGLE_SELECTION_LIST);
-    
-    BScrollView* scrollView = new CustomScrollView("contents scroll view", 
-        fContentListView);
-                                                            
-    BLayoutBuilder::Group<>(this)
-        .Add(scrollView, 1.0f)
-        .SetInsets(0.0f, -1.0f, -1.0f, -1.0f)
-    ;
+    SetWantsEvents(true);
+}
 
-    _InitContentPopulator();
+
+void
+PackageEntryColumn::DrawField(BField* field, BRect rect, BView* parent)
+{
+    BitmapStringField* bitmapField
+        = dynamic_cast<BitmapStringField*>(field);
+    BStringField* stringField = dynamic_cast<BStringField*>(field);
+
+    if (bitmapField != NULL) {
+        const BBitmap* bitmap = bitmapField->Bitmap();
+
+        // figure out the placement
+        float x = 0.0;
+        BRect r = bitmap ? bitmap->Bounds() : BRect(0, 0, 15, 15);
+        float y = rect.top + ((rect.Height() - r.Height()) / 2);
+        float width = 0.0;
+
+        switch (Alignment()) {
+            default:
+            case B_ALIGN_LEFT:
+            case B_ALIGN_CENTER:
+                x = rect.left + sTextMargin;
+                width = rect.right - (x + r.Width()) - (2 * sTextMargin);
+                r.Set(x + r.Width(), rect.top, rect.right - width, rect.bottom);
+                break;
+
+            case B_ALIGN_RIGHT:
+                x = rect.right - sTextMargin - r.Width();
+                width = (x - rect.left - (2 * sTextMargin));
+                r.Set(rect.left, rect.top, rect.left + width, rect.bottom);
+                break;
+        }
+
+        if (width != bitmapField->Width()) {
+            BString truncatedString(bitmapField->String());
+            parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
+            bitmapField->SetClippedString(truncatedString.String());
+            bitmapField->SetWidth(width);
+        }
+
+        // draw the bitmap
+        if (bitmap != NULL) {
+            parent->SetDrawingMode(B_OP_ALPHA);
+            parent->DrawBitmap(bitmap, BPoint(x, y));
+            parent->SetDrawingMode(B_OP_OVER);
+        }
+
+        // draw the string
+        DrawString(bitmapField->ClippedString(), parent, r);
+
+    } else if (stringField != NULL) {
+
+        float width = rect.Width() - (2 * sTextMargin);
+
+        if (width != stringField->Width()) {
+            BString truncatedString(stringField->String());
+
+            parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
+            stringField->SetClippedString(truncatedString.String());
+            stringField->SetWidth(width);
+        }
+
+        DrawString(stringField->ClippedString(), parent, rect);
+
+    } 
 }
 
 
-PackageContentsView::~PackageContentsView()
+int
+PackageEntryColumn::CompareFields(BField* field1, BField* field2)
 {
-    Clear();
+    BStringField* stringField1 = dynamic_cast<BStringField*>(field1);
+    BStringField* stringField2 = dynamic_cast<BStringField*>(field2);
+    if (stringField1 != NULL && stringField2 != NULL) {
+        // TODO: Locale aware string compare... not too important if
+        // package names are not translated.
+        return strcmp(stringField1->String(), stringField2->String());
+    }
+    return Inherited::CompareFields(field1, field2);
+}
 
-    delete_sem(fContentPopulatorSem);
-    if (fContentPopulator >= 0)
-        wait_for_thread(fContentPopulator, NULL);
+
+float
+PackageEntryColumn::GetPreferredWidth(BField *_field, BView* parent) const
+{
+    BitmapStringField* bitmapField
+        = dynamic_cast<BitmapStringField*>(_field);
+    BStringField* stringField = dynamic_cast<BStringField*>(_field);
+
+    float parentWidth = Inherited::GetPreferredWidth(_field, parent);
+    float width = 0.0;
+
+    if (bitmapField) {
+        const BBitmap* bitmap = bitmapField->Bitmap();
+        BFont font;
+        parent->GetFont(&font);
+        width = font.StringWidth(bitmapField->String()) + 3 * sTextMargin;
+        if (bitmap)
+            width += bitmap->Bounds().Width();
+        else
+            width += 16;
+    } else if (stringField) {
+        BFont font;
+        parent->GetFont(&font);
+        width = font.StringWidth(stringField->String()) + 2 * sTextMargin;
+    }
+    return max_c(width, parentWidth);
+}
+
+
+bool
+PackageEntryColumn::AcceptsField(const BField* field) const
+{
+    return dynamic_cast<const BStringField*>(field) != NULL;
 }
 
 
 void
-PackageContentsView::AttachedToWindow()
+PackageEntryColumn::InitTextMargin(BView* parent)
+{
+    BFont font;
+    parent->GetFont(&font);
+    sTextMargin = ceilf(font.Size() * 0.8);
+}
+
+
+// #pragma mark - PackageEntryRow
+
+
+enum {
+    kTitleColumn,
+    kSizeColumn,
+    kPermissionsColumn,
+    kLinkTargetsColumn,
+};
+
+PackageEntryRow::PackageEntryRow(const PackageEntry* entry, 
+                                                const BBitmap* bitmap = NULL)
+    :
+    Inherited(ceilf(be_plain_font->Size() * 1.8f)),
+    fPackageEntry(entry)
 {
-    BView::AttachedToWindow();
+    // Package icon and title
+    UpdateTitle(bitmap);
+
+    // Size
+    UpdateSize();
+
+    // Summary
+    UpdatePermissions();
+
+    // Target Links
+    UpdateLinkTargets();
+}
+
+PackageEntryRow::PackageEntryRow(BString msg) 
+{
+    SetField(new BStringField(msg), kTitleColumn);
 }
 
+PackageEntryRow::~PackageEntryRow()
+{
+}
 
+/*
 void
-PackageContentsView::AllAttached()
+PackageEntryRow::UpdateTitle()
 {
-    BView::AllAttached();
+        fTitle = new BitmapStringField(Entry());
+        SetField(fTitle, kTitleColumn);
+}*/
+void
+PackageEntryRow::UpdateTitle(const BBitmap* icon)
+{
+        fTitle = new BitmapStringField(Entry());
+        if(icon != NULL)
+            fTitle->SetBitmap(icon);
+        SetField(fTitle, kTitleColumn);
 }
 
 
 void
-PackageContentsView::SetPackage(const PackageInfoRef& package)
+PackageEntryRow::UpdateSize()
 {
-    if (fPackage == package)
+    PackageEntry* entry = (PackageEntry*) Entry();
+    if(S_ISDIR(entry->Mode())) {
+        SetField(new BStringField("-"), kSizeColumn);
+    } else {
+    char sizeBuffer[128];
+    SetField(new BStringField(string_for_size(
+                    (double) (entry->Data().Size()), sizeBuffer, 
+                                        sizeof(sizeBuffer))), kSizeColumn);
+    }
+}
+
+
+void
+PackageEntryRow::UpdatePermissions()
+{
+    PackageEntry* entry = (PackageEntry*) Entry();
+    if (entry == NULL)
         return;
+    mode_t mode = entry->Mode();
+    BString perms;
+    
+    perms += (S_ISDIR(mode) ? "d" : "-");
+    perms += ((mode & S_IRUSR) ? "r" : "-");
+    perms += ((mode & S_IWUSR) ? "w" : "-");
+    perms += ((mode & S_IXUSR) ? "x" : "-");
+    perms += ((mode & S_IRGRP) ? "r" : "-");
+    perms += ((mode & S_IWGRP) ? "w" : "-");
+    perms += ((mode & S_IXGRP) ? "x" : "-");
+    perms += ((mode & S_IROTH) ? "r" : "-");
+    perms += ((mode & S_IWOTH) ? "w" : "-");
+    perms += ((mode & S_IXOTH) ? "x" : "-");
+    
+    SetField(new BStringField(perms.String()), kPermissionsColumn);
+}
 
-//  printf("PackageContentsView::SetPackage(%s)\n",
-//      package.Get() != NULL ? package->Title().String() : "NULL");
 
-    Clear();
+void
+PackageEntryRow::UpdateLinkTargets()
+{
+    //TODO: Get link targets
+    BString targets(Entry()->SymlinkPath());
+    SetField(new BStringField(targets), kLinkTargetsColumn);
+}
 
-    {
-        BAutolock lock(&fPackageLock);
-        fPackage = package;
-    }
-    release_sem_etc(fContentPopulatorSem, 1, 0);
+
+void PackageEntryRow::SetBitmap(const BBitmap* bitmap) 
+{
+    if(fTitle != NULL)
+        fTitle->SetBitmap(bitmap);
 }
 
 
-void 
-PackageContentsView::Clear()
+// #pragma mark - private
+
+PackageEntryRow*
+PackageContentsView::_FindRow(const PackageEntry* entry, PackageEntryRow* parent)
 {
-    {
-        BAutolock lock(&fPackageLock);
-        fPackage.Unset();
+    for (int32 i = CountRows(parent) - 1; i >= 0; i--) {
+        PackageEntryRow* row = dynamic_cast<PackageEntryRow*>(RowAt(i, parent));
+        if (row != NULL && row->Entry() == entry)
+            return row;
+        if (CountRows(row) > 0) {
+            // recurse into child rows
+            row = _FindRow(entry, row);
+            if (row != NULL)
+                return row;
+        }
     }
 
-    fContentListView->MakeEmpty();
+    return NULL;
 }
 
 
-// #pragma mark - private
+PackageEntryRow*
+PackageContentsView::_FindRow(const BString& packageTitle, PackageEntryRow* parent)
+{
+    for (int32 i = CountRows(parent) - 1; i >= 0; i--) {
+        PackageEntryRow* row = dynamic_cast<PackageEntryRow*>(RowAt(i, parent));
+        if (row != NULL && row->Entry() != NULL
+            && row->Entry()->Name() == packageTitle) {
+            return row;
+        }
+        if (CountRows(row) > 0) {
+            // recurse into child rows
+            row = _FindRow(packageTitle, row);
+            if (row != NULL)
+                return row;
+        }
+    }
 
+    return NULL;
+}
 
 void
 PackageContentsView::_InitContentPopulator()
 {
+    printf("In _InitContentPopulator\n");
     fContentPopulatorSem = create_sem(0, "PopulatePackageContents");
     if (fContentPopulatorSem >= 0) {
         fContentPopulator = spawn_thread(&_ContentPopulatorThread,
             "Package Contents Populator", B_NORMAL_PRIORITY, this);
-        if (fContentPopulator >= 0)
+        if (fContentPopulator >= 0) {
             resume_thread(fContentPopulator);
+            printf("fContentPopulator resumed!");
+        }
     } else
         fContentPopulator = -1;
 }
@@ -332 +707 @@
 PackageContentsView::_ContentPopulatorThread(void* arg)
 {
     PackageContentsView* view = reinterpret_cast<PackageContentsView*>(arg);
-
+    printf("In _ContentPopulatorThread\n");
+    if(view == NULL) {
+        printf("_ContentPopulatorThread:: View null!\n");
+        return 1;
+    } else  printf("_ContentPopulatorThread:: View not null\n");
     while (acquire_sem(view->fContentPopulatorSem) == B_OK) {
+        printf("_ContentPopulatorThread: Acquiring sem");
         PackageInfoRef package;
         {
             BAutolock lock(&view->fPackageLock);
             package = view->fPackage;
         }
-
         if (package.Get() != NULL) {
-            if (!view->_PopuplatePackageContens(*package.Get())) {
+                printf("In _ContentPopulatorThread: Package not null\n");
+            if (!view->_PopulatePackageContents(view, *package.Get())) {
                 if (view->LockLooper()) {
-                    view->fContentListView->AddItem(
-                        new BStringItem(B_TRANSLATE("<Package contents not "
-                            "available for remote packages>")));
+                        printf("In _ContentPopulatorThread:Remote package\n");
+                    PackageEntryRow* notAvailable = new PackageEntryRow(
+                        "<Package contents not available for remote packages>");
+                    view->AddRow(notAvailable);
+                    view->ExpandOrCollapse(notAvailable, true);
                     view->UnlockLooper();
                 }
             }
-        }
+        }else   printf("In _ContentPopulatorThread: package null\n");
     }
-
     return 0;
 }
 
 
 bool
-PackageContentsView::_PopuplatePackageContens(const PackageInfo& package)
+PackageContentsView::_PopulatePackageContents(PackageContentsView* view,
+                                    const PackageInfo& package)
 {
     BPath packagePath;
-
+    printf("In _PopulatePackageContents\n");
     // Obtain path to the package file
     if (package.IsLocalFile()) {
         BString pathString = package.LocalFilePath();
@@ -378 +760 @@
                 return false;
             }
         } else {
-            printf("PackageContentsView::_PopuplatePackageContens(): "
+            printf("PackageContentsView::_PopulatePackageContents(): "
                 "unknown install location");
             return false;
         }
@@ -399 +781 @@
     }
 
     // Scan package contents and populate list
-    PackageContentOutliner contentHandler(fContentListView, &package,
-        fPackageLock, fPackage);
+    PackageContentOutliner contentHandler( &package,
+        fPackageLock, fPackage, packagePath, view);
     status = reader.ParseContent(&contentHandler);
     if (status != B_OK) {
         printf("PackageContentsView::SetPackage(): "
@@ -424 +806 @@
 
     return B_PACKAGE_INSTALLATION_LOCATION_SYSTEM;
 }
+
+
+// #pragma mark - PackageContentsView
+
+
+PackageContentsView::PackageContentsView()
+    :
+    BColumnListView("package contents view", 0, B_FANCY_BORDER, true),
+    fPackageLock("package contents populator lock")
+{
+    AddColumn(new PackageEntryColumn(B_TRANSLATE("Name"), 375, 50, 400,
+        B_TRUNCATE_MIDDLE), kTitleColumn);
+    AddColumn(new PackageEntryColumn(B_TRANSLATE("Size"), 150, 50, 150,
+        B_TRUNCATE_MIDDLE), kSizeColumn);
+    AddColumn(new PackageEntryColumn(B_TRANSLATE("Permissions"), 100, 80, 100,
+        B_TRUNCATE_MIDDLE), kPermissionsColumn);
+    AddColumn(new PackageEntryColumn(B_TRANSLATE("Link Targets"), 300, 60, 400,
+        B_TRUNCATE_END), kLinkTargetsColumn);
+//  fItemCountView = new ItemCountView();
+//  AddStatusView(fItemCountView);
+    printf("Initializing population\n");
+    _InitContentPopulator();
+}
+
+
+PackageContentsView::~PackageContentsView()
+{
+    Clear();
+    delete_sem(fContentPopulatorSem);
+    if (fContentPopulator >= 0)
+        wait_for_thread(fContentPopulator, NULL);
+}
+
+
+void
+PackageContentsView::AttachedToWindow()
+{
+    BColumnListView::AttachedToWindow();
+    PackageEntryColumn::InitTextMargin(ScrollView());
+}
+
+
+void
+PackageContentsView::AllAttached()
+{
+    BColumnListView::AllAttached();
+
+    SetSortingEnabled(true);
+    SetSortColumn(ColumnAt(0), false, true);
+}
+
+
+void
+PackageContentsView::MessageReceived(BMessage* message)
+{
+    switch (message->what) {
+/*      case MSG_UPDATE_PACKAGE:
+        {
+            BString title;
+            uint32 changes;
+            if (message->FindString("title", &title) != B_OK
+                || message->FindUInt32("changes", &changes) != B_OK) {
+                break;
+            }
+
+            PackageEntryRow* row = _FindRow(title);
+            if (row != NULL) {
+                if ((changes & PKG_CHANGED_SUMMARY) != 0)
+                    row->UpdateTitle(row->PackageEntry());
+                if ((changes & PKG_CHANGED_RATINGS) != 0)
+                    row->UpdateSize(row->PackageEntry());
+                if ((changes & PKG_CHANGED_STATE) != 0)
+                    row->UpdatePermissions(row->PackageEntry());
+                if ((changes & PKG_CHANGED_ICON) != 0)
+                    row->UpdateLinkTargets(row->PackageEntry());
+            }
+            break;
+        }
+*/
+        default:
+            BColumnListView::MessageReceived(message);
+            break;
+    }
+}
+
+
+void
+PackageContentsView::SelectionChanged()
+{
+    BColumnListView::SelectionChanged();
+
+    BMessage message(MSG_PACKAGE_SELECTED);
+
+    PackageEntryRow* selected = dynamic_cast<PackageEntryRow*>(CurrentSelection());
+    if (selected != NULL)
+        message.AddString("title", selected->Entry()->Name());
+
+    Window()->PostMessage(&message);
+}
+
+
+void
+PackageContentsView::Clear()
+{
+//  fItemCountView->SetItemCount(0);
+    BColumnListView::Clear();
+    BAutolock lock(&fPackageLock);
+    fPackage.Unset();
+}
+
+
+void
+PackageContentsView::AddPackageEntry(const PackageEntry& package)
+{
+    PackageEntryRow* packageRow =(PackageEntryRow*) _FindRow(&package);
+    printf("In AddPackageEntry: %s\n", package.Name());
+    // forget about it if this package is already in the listview
+    if (packageRow != NULL)
+        return;
+
+    BAutolock _(fPackageLock);
+
+    // create the row for this package
+    packageRow = new PackageEntryRow(&package);
+
+    // add the row, parent may be NULL (add at top level)
+    AddRow(packageRow);
+
+    // make sure the row is initially expanded
+    ExpandOrCollapse(packageRow, true);
+
+//  fItemCountView->SetItemCount(CountRows());
+}
+
+
+void
+PackageContentsView::SelectPackageEntry(const PackageEntry* entry)
+{
+    PackageEntryRow* row = (PackageEntryRow*) _FindRow(entry);
+    BRow* selected = CurrentSelection();
+    if (row != selected)
+        DeselectAll();
+    if (row != NULL) {
+        AddToSelection(row);
+        SetFocusRow(row, false);
+        ScrollTo(row);
+    }
+}
+
+
+void
+PackageContentsView::SetPackage(const PackageInfoRef& package)
+{
+if (fPackage == package)
+        return;
+
+//  printf("PackageContentsView::SetPackage(%s)\n",
+//      package.Get() != NULL ? package->Title().String() : "NULL");
+
+    Clear();
+
+    {
+        BAutolock lock(&fPackageLock);
+        fPackage = package;
+    }
+    release_sem_etc(fContentPopulatorSem, 1, 0);
+}
+

src/apps/haikudepot/ui/PackageContentsView.h

@@ -1 +1 @@
 /*
- * Copyright 2015, TigerKid001.
+ * Copyright 2015, Stephan Aßmus <superstippi@gmx.de>.
+ * Copyright 2015, Sidhant Sharma <tigerkid001@gmail.com>.
  * All rights reserved. Distributed under the terms of the MIT License.
  */
+
 #ifndef PACKAGE_CONTENTS_VIEW_H
 #define PACKAGE_CONTENTS_VIEW_H
 
+#include <ColumnListView.h>
+#include <ColumnTypes.h>
 #include <Locker.h>
-#include <View.h>
+#include <package/hpkg/PackageEntry.h>
 
 #include "PackageInfo.h"
 
-class BOutlineListView;
+using BPackageKit::BHPKG::BPackageEntry;
 
+class PackageEntryRow;
+class PackageEntry;
 
-class PackageContentsView : public BView {
+class PackageContentsView : public BColumnListView {
 public:
-                                PackageContentsView(const char* name);
+                                PackageContentsView();
     virtual                     ~PackageContentsView();
 
     virtual void                AttachedToWindow();
     virtual void                AllAttached();
 
+    void                            MessageReceived(BMessage*);
+    virtual void                SelectionChanged();
+
+    virtual void                Clear();
+    
+            void                AddPackageEntry(const PackageEntry& package);
             void                SetPackage(const PackageInfoRef& package);
-            void                Clear();
+
+            void                SelectPackageEntry(const PackageEntry* entry);
 
 private:
+            PackageEntryRow*            _FindRow(const PackageEntry* entry,
+                                    PackageEntryRow* parent = NULL);
+            PackageEntryRow*            _FindRow(const BString& packageTitle,
+                                    PackageEntryRow* parent = NULL);
             void                _InitContentPopulator();
     static  int32               _ContentPopulatorThread(void* arg);
-            bool                _PopuplatePackageContens(
-                                    const PackageInfo& package);
+            bool            _PopulatePackageContents(PackageContentsView* view,
+                                            const PackageInfo& package);
             int32               _InstallLocation(
                                     const PackageInfo& package) const;
 
 private:
-            BOutlineListView*   fContentListView;
-
+//          class ItemCountView;
+            friend class PackageContentOutliner;
             thread_id           fContentPopulator;
             sem_id              fContentPopulatorSem;
             BLocker             fPackageLock;
             PackageInfoRef      fPackage;
+//          ItemCountView*      fItemCountView;
 };
 
 #endif // PACKAGE_CONTENTS_VIEW_H

src/apps/haikudepot/ui/PackageInfoView.cpp

@@ -1178 +1178 @@
         SetViewColor(tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
             kContentTint));
 
-        fPackageContents = new PackageContentsView("contents_list");
+        fPackageContents = new PackageContentsView();
         AddChild(fPackageContents);
 
     }