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

File bug#11563-patch-4.patch, 32.3 KB (added by TigerKid001, 5 years ago)

Patch for comment 25

  • src/apps/haikudepot/ui/PackageContentsView.cpp

    From 832fc3670065280cb04606cce37c0e3e4b175369 Mon Sep 17 00:00:00 2001
    From: "Sidhant Sharma [:TigerKid001]" <tigerkid001@gmail.com>
    Date: Thu, 12 Feb 2015 13:42:27 +0530
    Subject: [PATCH] Contents tab patch 4
    
    ---
     src/apps/haikudepot/ui/PackageContentsView.cpp | 866 ++++++++++++++++++++-----
     src/apps/haikudepot/ui/PackageContentsView.h   |  38 +-
     src/apps/haikudepot/ui/PackageInfoView.cpp     |   2 +-
     3 files changed, 737 insertions(+), 169 deletions(-)
    
    diff --git a/src/apps/haikudepot/ui/PackageContentsView.cpp b/src/apps/haikudepot/ui/PackageContentsView.cpp
    index 4e900ab..97e5e43 100644
    a b  
    11/*
    2  * Copyright 2015, TigerKid001.
     2 * Copyright 2015, Stephan Aßmus <superstippi@gmx.de>.
     3 * Copyright 2015, Sidhant Sharma <tigerkid001@gmail.com>.
    34 * All rights reserved. Distributed under the terms of the MIT License.
    45 */
    56
    67#include "PackageContentsView.h"
     8#include "MainWindow.h"
    79
    810#include <algorithm>
    911#include <stdio.h>
     
    1113#include <Autolock.h>
    1214#include <Catalog.h>
    1315#include <FindDirectory.h>
    14 #include <MessageFormat.h>
    1516#include <LayoutBuilder.h>
    1617#include <LayoutUtils.h>
    17 #include <OutlineListView.h>
     18#include <MessageFormat.h>
     19#include <Mime.h>
     20#include <NodeInfo.h>
    1821#include <Path.h>
    1922#include <ScrollBar.h>
    2023#include <ScrollView.h>
    2124#include <StringItem.h>
     25#include <StringForSize.h>
    2226
    2327#include <package/PackageDefs.h>
    2428#include <package/hpkg/NoErrorOutput.h>
    2529#include <package/hpkg/PackageContentHandler.h>
    2630#include <package/hpkg/PackageEntry.h>
     31#include <package/hpkg/PackageEntryAttribute.h>
    2732#include <package/hpkg/PackageReader.h>
    2833
    2934using namespace BPackageKit;
    using BPackageKit::BHPKG::BPackageReader;  
    3944#define B_TRANSLATION_CONTEXT "PackageContentsView"
    4045
    4146
    42 //! Layouts the scrollbar so it looks nice with no border and the document
    43 // window look.
    44 class CustomScrollView : public BScrollView {
     47class PackageEntry : public BPackageEntry {
    4548public:
    46     CustomScrollView(const char* name, BView* target)
    47         :
    48         BScrollView(name, target, 0, false, true, B_NO_BORDER)
    49     {
    50     }
     49                                PackageEntry(const BPackageEntry* entry, const BString path);
     50        virtual             ~PackageEntry();
     51        BString             Path() const
     52                                    {return fPath;}
     53private:
     54        BString fPath;
     55};
    5156
    52     virtual void DoLayout()
    53     {
    54         BRect innerFrame = Bounds();
    55         innerFrame.right -= B_V_SCROLL_BAR_WIDTH + 1;
     57// A field type displaying both a bitmap and a string so that the
     58// tree display looks nicer (both text and bitmap are indented)
     59class BitmapStringField : public BStringField {
     60    typedef BStringField Inherited;
     61public:
     62                                        BitmapStringField(const PackageEntry* entry);
     63    virtual                         ~BitmapStringField();
    5664
    57         BView* target = Target();
    58         if (target != NULL) {
    59             Target()->MoveTo(innerFrame.left, innerFrame.top);
    60             Target()->ResizeTo(innerFrame.Width(), innerFrame.Height());
    61         }
     65            void                        SetBitmap(const BBitmap* bitmap);
     66            const BBitmap*  Bitmap() const
     67                                        {return NULL/*fIcon*/;}
     68private:
     69        const BBitmap* fIcon;
     70};
    6271
    63         BScrollBar* scrollBar = ScrollBar(B_VERTICAL);
    64         if (scrollBar != NULL) {
    65             BRect rect = innerFrame;
    66             rect.left = rect.right + 1;
    67             rect.right = rect.left + B_V_SCROLL_BAR_WIDTH;
    68             rect.bottom -= B_H_SCROLL_BAR_HEIGHT;
    6972
    70             scrollBar->MoveTo(rect.left, rect.top);
    71             scrollBar->ResizeTo(rect.Width(), rect.Height());
    72         }
    73     }
    74 };
     73// BColumn for PackageContentsView which knows how to render
     74// a BitmapStringField
     75class PackageEntryColumn : public BTitledColumn {
     76    typedef BTitledColumn Inherited;
     77public:
     78                                PackageEntryColumn(const char* title,
     79                                    float width, float minWidth,
     80                                    float maxWidth, uint32 truncateMode,
     81                                    alignment align = B_ALIGN_LEFT);
     82
     83    virtual void                DrawField(BField* field, BRect rect,
     84                                    BView* parent);
     85    virtual int                 CompareFields(BField* field1, BField* field2);
     86    virtual float               GetPreferredWidth(BField* field,
     87                                    BView* parent) const;
    7588
    76 // #pragma mark - PackageEntryItem
     89    virtual bool                AcceptsField(const BField* field) const;
    7790
     91    static  void                InitTextMargin(BView* parent);
    7892
    79 class PackageEntryItem : public BStringItem {
     93private:
     94            uint32              fTruncateMode;
     95    static  float               sTextMargin;
     96};
     97
     98
     99// BRow for the PartitionListView
     100class PackageEntryRow : public BRow {
     101    typedef BRow Inherited;
    80102public:
    81     PackageEntryItem(const BPackageEntry* entry, const BString& path)
    82         :
    83         BStringItem(entry->Name()),
    84         fPath(path)
    85     {
    86         if (fPath.Length() > 0)
    87             fPath.Append("/");
    88         fPath.Append(entry->Name());
    89     }
    90    
    91     inline const BString& EntryPath() const
    92     {
    93         return fPath;
    94     }
     103                                PackageEntryRow(const PackageEntry* entry,
     104                                                    const BBitmap* bitmap =NULL);
     105                                PackageEntryRow(BString msg);
     106    virtual                     ~PackageEntryRow();
     107
     108            const PackageEntry* Entry()
     109                                    { return fPackageEntry; }
     110
     111            void                UpdateTitle(const BBitmap* bitmap = NULL);
     112            void                UpdateSize();
     113            void                UpdatePermissions();
     114            void                UpdateLinkTargets();
     115            void                SetBitmap(const BBitmap* bitmap);
    95116
    96117private:
    97     BString fPath;
     118            BitmapStringField* fTitle;
     119            const PackageEntry*     fPackageEntry;
    98120};
    99121
    100122
    101 // #pragma mark - PackageContentOutliner
     123// #pragma mark - PackageEntry
    102124
     125PackageEntry::PackageEntry(const BPackageEntry* entry, const BString path)
     126    :
     127    BPackageEntry(*entry),
     128    fPath(path)
     129{
     130        //TODO: Something!
     131}
     132
     133
     134PackageEntry::~PackageEntry()
     135{
     136}
    103137
    104 class PackageContentOutliner : public BPackageContentHandler {
     138
     139// #pragma mark - BitmapStringField
     140
     141BitmapStringField::BitmapStringField(   const PackageEntry* entry)
     142    :
     143    Inherited(entry->Name())
     144{
     145    //SetBitmap(entry);
     146}
     147
     148
     149BitmapStringField::~BitmapStringField()
     150{
     151}
     152
     153
     154void
     155BitmapStringField::SetBitmap(const BBitmap* icon)
     156{
     157    /*
     158    //Get mimetype of package entry and set icon
     159    BMimeType mimeType;
     160    BNode node(entry->Path().String());
     161    BNodeInfo nodeInfo(&node);
     162    BBitmap* icon = new BBitmap(BRect(0,0,15,15), B_RGBA32);
     163//  char mimeTypeString[B_MIME_TYPE_LENGTH];
     164    if (nodeInfo.GetIcon(icon, B_MINI_ICON) != B_OK) {
     165            if(mimeType.GetIcon(icon, B_MINI_ICON) != B_OK) {
     166                printf("Failed to get icon for %s,%s!", entry->Name(),
     167                                                entry->Path().String());
     168                return;
     169        }
     170        nodeInfo.SetIcon(icon, B_MINI_ICON);   
     171    } else
     172        mimeType.SetIcon(icon, B_MINI_ICON);
     173    */
     174   
     175    fIcon = icon;
     176    // TODO: cause a redraw?
     177}
     178
     179
     180// #pragma mark - PackageContentOutliner
     181
     182class PackageContentOutliner
     183            : public BPackageContentHandler {
    105184public:
    106     PackageContentOutliner(BOutlineListView* listView,
    107             const PackageInfo* packageInfo,
    108             BLocker& packageLock, PackageInfoRef& packageInfoRef)
     185    PackageContentOutliner(const PackageInfo* packageInfo,
     186            BLocker& packageLock, PackageInfoRef& packageInfoRef ,
     187            BPath packagePath, PackageContentsView* view)
    109188        :
    110         fListView(listView),
     189        fView(view),
    111190        fLastParentEntry(NULL),
    112         fLastParentItem(NULL),
     191        fLastParentRow(NULL),
    113192        fLastEntry(NULL),
    114         fLastItem(NULL),
    115 
     193        fLastRow(NULL),
    116194        fPackageInfoToPopulate(packageInfo),
    117195        fPackageLock(packageLock),
    118         fPackageInfoRef(packageInfoRef)
     196        fPackageInfoRef(packageInfoRef),
     197        fPackagePath(packagePath)
    119198    {
    120199    }
    121200
    122201    virtual status_t HandleEntry(BPackageEntry* entry)
    123202    {
    124 //      printf("HandleEntry(%s/%s)\n",
    125 //          entry->Parent() != NULL ? entry->Parent()->Name() : "NULL",
    126 //          entry->Name());
     203    /*  printf("\n**HandleEntry(%s/%s)\n",
     204            entry->Parent() != NULL ? entry->Parent()->Name() : "NULL",
     205            entry->Name());
    127206
    128         if (!fListView->LockLooper())
     207    if (!fView->LockLooper())
    129208            return B_ERROR;
    130209
    131210        // Check if we are still supposed to popuplate the list
    132211        if (fPackageInfoRef.Get() != fPackageInfoToPopulate) {
    133 //          printf("stopping package content population\n");
    134             fListView->UnlockLooper();
     212            printf("stopping package content population\n");
     213            fView->UnlockLooper();
    135214            return B_ERROR;
    136215        }
    137216
    138217        BString path;
    139218        const BPackageEntry* parent = entry->Parent();
     219       
    140220        while (parent != NULL) {
    141221            if (path.Length() > 0)
    142222                path.Prepend("/");
    143223            path.Prepend(parent->Name());
    144224            parent = parent->Parent();
    145225        }
    146 
    147         PackageEntryItem* item = new PackageEntryItem(entry, path);
    148 
    149         if (entry->Parent() == NULL) {
    150 //          printf("  adding root entry\n");
    151             fListView->AddItem(item);
     226        path.Prepend("/");
     227        path.Prepend(fPackagePath.Path());
     228        BPath entryPath(path.String());
     229        printf("\npath: %s\n",path.String());
     230        printf("\\m/%s,\\m/%s\n", fPackagePath.Path(), entryPath.Path());
     231        // create the row for this package
     232        packageRow = new PackageEntryRow(
     233                                        new PackageEntry(entry, path));
     234//      BitmapStringField* item = new BitmapStringField(entry);
     235
     236    if (entry->Parent() == NULL) {
     237            // add the row, parent may be NULL (add at top level)
     238            fView->AddRow(packageRow);
    152239            fLastParentEntry = NULL;
    153             fLastParentItem = NULL;
     240            fLastParentRow = NULL;
    154241        } else if (entry->Parent() == fLastEntry) {
    155 //          printf("  adding to last entry %s\n", fLastEntry->Name());
    156             fListView->AddUnder(item, fLastItem);
     242            fView->AddRow(packageRow, fLastRow);
    157243            fLastParentEntry = fLastEntry;
    158             fLastParentItem = fLastItem;
     244            fLastParentRow = fLastRow;
    159245        } else if (entry->Parent() == fLastParentEntry) {
    160 //          printf("  adding to last parent %s\n", fLastParentEntry->Name());
    161             fListView->AddUnder(item, fLastParentItem);
     246            fView->AddRow(packageRow, fLastParentRow);
    162247        } else {
    163248            // Not the last parent entry, need to search for the parent
    164249            // among the already added list items.
    165250            bool foundParent = false;
    166             for (int32 i = 0; i < fListView->FullListCountItems(); i++) {
    167                 PackageEntryItem* listItem
    168                     = dynamic_cast<PackageEntryItem*>(
    169                         fListView->FullListItemAt(i));
    170                 if (listItem == NULL)
    171                     continue;
    172                 if (listItem->EntryPath() == path) {
    173                     fLastParentEntry = entry->Parent();
    174                     fLastParentItem = listItem;
    175 //                  printf("  found parent %s\n", listItem->Text());
    176                     fListView->AddUnder(item, listItem);
    177                     foundParent = true;
    178                     break;
    179                 }
     251            PackageEntryRow* row = (PackageEntryRow*) fView->_FindRow(
     252                                                entry->Parent()->Name());
     253            if(row == NULL) {
     254                foundParent = false;
     255            } else {
     256                fLastParentEntry = entry->Parent();
     257                fLastParentRow = row;
     258                fView->AddRow(packageRow, row);
     259                foundParent = true;
    180260            }
     261           
    181262            if (!foundParent) {
    182263                // NOTE: Should not happen. Just add this entry at the
    183264                // root level.
    184 //              printf("Did not find parent entry for %s (%s)!\n",
    185 //                  entry->Name(), entry->Parent()->Name());
    186                 fListView->AddItem(item);
     265                printf("Did not find parent entry for %s (%s)!\n",
     266                entry->Name(), entry->Parent()->Name());
     267                fView->AddRow(packageRow);
    187268                fLastParentEntry = NULL;
    188                 fLastParentItem = NULL;
     269                fLastParentRow = NULL;
    189270            }
    190271        }
    191 
     272        // make sure the row is initially expanded
     273        fView->ExpandOrCollapse(packageRow, true);
    192274        fLastEntry = entry;
    193         fLastItem = item;
     275        fLastRow = packageRow;
    194276
    195         fListView->UnlockLooper();
    196 
    197         return B_OK;
     277    fView->UnlockLooper();*/
     278    printf("\n\t\t******HandeEntry*******\n");
     279    return B_OK;
    198280    }
    199281
    200282    virtual status_t HandleEntryAttribute(BPackageEntry* entry,
    201283        BPackageEntryAttribute* attribute)
    202284    {
     285        int32 attr = (int32) attribute->Data().InlineData();
     286        SharedBitmap shared(attr);
     287        fPackageIcon = (BBitmap*) shared.Bitmap(SharedBitmap::SIZE_16);
     288        printf("\n\t\t******HandeEntryAttribute*******\n");
     289        if(fPackageIcon != NULL)
     290            printf("fPackageIcon not null");
     291//          return B_ERROR;
    203292        return B_OK;
    204293    }
    205294
    206295    virtual status_t HandleEntryDone(BPackageEntry* entry)
    207296    {
     297        if (!fView->LockLooper())
     298            return B_ERROR;
     299
     300        // Check if we are still supposed to popuplate the list
     301        if (fPackageInfoRef.Get() != fPackageInfoToPopulate) {
     302            printf("stopping package content population\n");
     303            fView->UnlockLooper();
     304            return B_ERROR;
     305        }
     306
     307        BString path;
     308        const BPackageEntry* parent = entry->Parent();
     309       
     310        while (parent != NULL) {
     311            if (path.Length() > 0)
     312                path.Prepend("/");
     313            path.Prepend(parent->Name());
     314            parent = parent->Parent();
     315        }
     316        path.Prepend("/");
     317        path.Prepend(fPackagePath.Path());
     318        BPath entryPath(path.String());
     319        printf("\npath: %s\n",path.String());
     320        printf("\\m/%s,\\m/%s\n", fPackagePath.Path(), entryPath.Path());
     321        // create the row for this package
     322        PackageEntryRow* packageRow = new PackageEntryRow(
     323                                new PackageEntry(entry, path));
     324        if (entry->Parent() == NULL) {
     325            // add the row, parent may be NULL (add at top level)
     326            fView->AddRow(packageRow);
     327            fLastParentEntry = NULL;
     328            fLastParentRow = NULL;
     329        } else if (entry->Parent() == fLastEntry) {
     330            fView->AddRow(packageRow, fLastRow);
     331            fLastParentEntry = fLastEntry;
     332            fLastParentRow = fLastRow;
     333        } else if (entry->Parent() == fLastParentEntry) {
     334            fView->AddRow(packageRow, fLastParentRow);
     335        } else {
     336            // Not the last parent entry, need to search for the parent
     337            // among the already added list items.
     338            bool foundParent = false;
     339            PackageEntryRow* row = (PackageEntryRow*) fView->_FindRow(
     340                                                entry->Parent()->Name());
     341            if(row == NULL) {
     342                foundParent = false;
     343            } else {
     344                fLastParentEntry = entry->Parent();
     345                fLastParentRow = row;
     346                fView->AddRow(packageRow, row);
     347                foundParent = true;
     348            }
     349           
     350            if (!foundParent) {
     351                // NOTE: Should not happen. Just add this entry at the
     352                // root level.
     353                printf("Did not find parent entry for %s (%s)!\n",
     354                entry->Name(), entry->Parent()->Name());
     355                fView->AddRow(packageRow);
     356                fLastParentEntry = NULL;
     357                fLastParentRow = NULL;
     358            }
     359        }
     360        // make sure the row is initially expanded
     361        fView->ExpandOrCollapse(packageRow, true);
     362        fLastEntry = entry;
     363        fLastRow = packageRow;
     364
     365    fView->UnlockLooper();
     366    printf("\n\t\t******HandeEntryDone*******\n");
    208367        return B_OK;
    209368    }
    210369
    public:  
    219378    }
    220379   
    221380private:
    222     BOutlineListView*       fListView;
    223381
     382    PackageContentsView* fView;
     383   
    224384    const BPackageEntry*    fLastParentEntry;
    225     PackageEntryItem*       fLastParentItem;
     385    PackageEntryRow*        fLastParentRow;
    226386
    227387    const BPackageEntry*    fLastEntry;
    228     PackageEntryItem*       fLastItem;
     388    PackageEntryRow*        fLastRow;
    229389
    230390    const PackageInfo*      fPackageInfoToPopulate;
    231391    BLocker&                fPackageLock;
    232     PackageInfoRef&         fPackageInfoRef;
     392    PackageInfoRef          fPackageInfoRef;
     393    BPath                   fPackagePath;
     394    BBitmap*                fPackageIcon;
    233395};
    234396
    235397
    236 // #pragma mark - PackageContentView
     398// #pragma mark - PackageEntryColumn
     399
    237400
     401float PackageEntryColumn::sTextMargin = 0.0;
    238402
    239 PackageContentsView::PackageContentsView(const char* name)
     403PackageEntryColumn::PackageEntryColumn(const char* title, float width, float minWidth,
     404        float maxWidth, uint32 truncateMode, alignment align)
    240405    :
    241     BView("package_contents_view", B_WILL_DRAW),
    242     fPackageLock("package contents populator lock")
     406    Inherited(title, width, minWidth, maxWidth, align),
     407    fTruncateMode(truncateMode)
    243408{
    244     fContentListView = new BOutlineListView("content list view",
    245         B_SINGLE_SELECTION_LIST);
    246    
    247     BScrollView* scrollView = new CustomScrollView("contents scroll view",
    248         fContentListView);
    249                                                            
    250     BLayoutBuilder::Group<>(this)
    251         .Add(scrollView, 1.0f)
    252         .SetInsets(0.0f, -1.0f, -1.0f, -1.0f)
    253     ;
     409    SetWantsEvents(true);
     410}
    254411
    255     _InitContentPopulator();
     412
     413void
     414PackageEntryColumn::DrawField(BField* field, BRect rect, BView* parent)
     415{
     416    BitmapStringField* bitmapField
     417        = dynamic_cast<BitmapStringField*>(field);
     418    BStringField* stringField = dynamic_cast<BStringField*>(field);
     419
     420    if (bitmapField != NULL) {
     421        const BBitmap* bitmap = bitmapField->Bitmap();
     422
     423        // figure out the placement
     424        float x = 0.0;
     425        BRect r = bitmap ? bitmap->Bounds() : BRect(0, 0, 15, 15);
     426        float y = rect.top + ((rect.Height() - r.Height()) / 2);
     427        float width = 0.0;
     428
     429        switch (Alignment()) {
     430            default:
     431            case B_ALIGN_LEFT:
     432            case B_ALIGN_CENTER:
     433                x = rect.left + sTextMargin;
     434                width = rect.right - (x + r.Width()) - (2 * sTextMargin);
     435                r.Set(x + r.Width(), rect.top, rect.right - width, rect.bottom);
     436                break;
     437
     438            case B_ALIGN_RIGHT:
     439                x = rect.right - sTextMargin - r.Width();
     440                width = (x - rect.left - (2 * sTextMargin));
     441                r.Set(rect.left, rect.top, rect.left + width, rect.bottom);
     442                break;
     443        }
     444
     445        if (width != bitmapField->Width()) {
     446            BString truncatedString(bitmapField->String());
     447            parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
     448            bitmapField->SetClippedString(truncatedString.String());
     449            bitmapField->SetWidth(width);
     450        }
     451
     452        // draw the bitmap
     453        if (bitmap != NULL) {
     454            parent->SetDrawingMode(B_OP_ALPHA);
     455            parent->DrawBitmap(bitmap, BPoint(x, y));
     456            parent->SetDrawingMode(B_OP_OVER);
     457        }
     458
     459        // draw the string
     460        DrawString(bitmapField->ClippedString(), parent, r);
     461
     462    } else if (stringField != NULL) {
     463
     464        float width = rect.Width() - (2 * sTextMargin);
     465
     466        if (width != stringField->Width()) {
     467            BString truncatedString(stringField->String());
     468
     469            parent->TruncateString(&truncatedString, fTruncateMode, width + 2);
     470            stringField->SetClippedString(truncatedString.String());
     471            stringField->SetWidth(width);
     472        }
     473
     474        DrawString(stringField->ClippedString(), parent, rect);
     475
     476    }
    256477}
    257478
    258479
    259 PackageContentsView::~PackageContentsView()
     480int
     481PackageEntryColumn::CompareFields(BField* field1, BField* field2)
    260482{
    261     Clear();
     483    BStringField* stringField1 = dynamic_cast<BStringField*>(field1);
     484    BStringField* stringField2 = dynamic_cast<BStringField*>(field2);
     485    if (stringField1 != NULL && stringField2 != NULL) {
     486        // TODO: Locale aware string compare... not too important if
     487        // package names are not translated.
     488        return strcmp(stringField1->String(), stringField2->String());
     489    }
     490    return Inherited::CompareFields(field1, field2);
     491}
    262492
    263     delete_sem(fContentPopulatorSem);
    264     if (fContentPopulator >= 0)
    265         wait_for_thread(fContentPopulator, NULL);
     493
     494float
     495PackageEntryColumn::GetPreferredWidth(BField *_field, BView* parent) const
     496{
     497    BitmapStringField* bitmapField
     498        = dynamic_cast<BitmapStringField*>(_field);
     499    BStringField* stringField = dynamic_cast<BStringField*>(_field);
     500
     501    float parentWidth = Inherited::GetPreferredWidth(_field, parent);
     502    float width = 0.0;
     503
     504    if (bitmapField) {
     505        const BBitmap* bitmap = bitmapField->Bitmap();
     506        BFont font;
     507        parent->GetFont(&font);
     508        width = font.StringWidth(bitmapField->String()) + 3 * sTextMargin;
     509        if (bitmap)
     510            width += bitmap->Bounds().Width();
     511        else
     512            width += 16;
     513    } else if (stringField) {
     514        BFont font;
     515        parent->GetFont(&font);
     516        width = font.StringWidth(stringField->String()) + 2 * sTextMargin;
     517    }
     518    return max_c(width, parentWidth);
     519}
     520
     521
     522bool
     523PackageEntryColumn::AcceptsField(const BField* field) const
     524{
     525    return dynamic_cast<const BStringField*>(field) != NULL;
    266526}
    267527
    268528
    269529void
    270 PackageContentsView::AttachedToWindow()
     530PackageEntryColumn::InitTextMargin(BView* parent)
     531{
     532    BFont font;
     533    parent->GetFont(&font);
     534    sTextMargin = ceilf(font.Size() * 0.8);
     535}
     536
     537
     538// #pragma mark - PackageEntryRow
     539
     540
     541enum {
     542    kTitleColumn,
     543    kSizeColumn,
     544    kPermissionsColumn,
     545    kLinkTargetsColumn,
     546};
     547
     548PackageEntryRow::PackageEntryRow(const PackageEntry* entry,
     549                                                const BBitmap* bitmap = NULL)
     550    :
     551    Inherited(ceilf(be_plain_font->Size() * 1.8f)),
     552    fPackageEntry(entry)
    271553{
    272     BView::AttachedToWindow();
     554    // Package icon and title
     555    UpdateTitle(bitmap);
     556
     557    // Size
     558    UpdateSize();
     559
     560    // Summary
     561    UpdatePermissions();
     562
     563    // Target Links
     564    UpdateLinkTargets();
     565}
     566
     567PackageEntryRow::PackageEntryRow(BString msg)
     568{
     569    SetField(new BStringField(msg), kTitleColumn);
    273570}
    274571
     572PackageEntryRow::~PackageEntryRow()
     573{
     574}
    275575
     576/*
    276577void
    277 PackageContentsView::AllAttached()
     578PackageEntryRow::UpdateTitle()
    278579{
    279     BView::AllAttached();
     580        fTitle = new BitmapStringField(Entry());
     581        SetField(fTitle, kTitleColumn);
     582}*/
     583void
     584PackageEntryRow::UpdateTitle(const BBitmap* icon)
     585{
     586        fTitle = new BitmapStringField(Entry());
     587        if(icon != NULL)
     588            fTitle->SetBitmap(icon);
     589        SetField(fTitle, kTitleColumn);
    280590}
    281591
    282592
    283593void
    284 PackageContentsView::SetPackage(const PackageInfoRef& package)
     594PackageEntryRow::UpdateSize()
    285595{
    286     if (fPackage == package)
     596    PackageEntry* entry = (PackageEntry*) Entry();
     597    if(S_ISDIR(entry->Mode())) {
     598        SetField(new BStringField("-"), kSizeColumn);
     599    } else {
     600    char sizeBuffer[128];
     601    SetField(new BStringField(string_for_size(
     602                    (double) (entry->Data().Size()), sizeBuffer,
     603                                        sizeof(sizeBuffer))), kSizeColumn);
     604    }
     605}
     606
     607
     608void
     609PackageEntryRow::UpdatePermissions()
     610{
     611    PackageEntry* entry = (PackageEntry*) Entry();
     612    if (entry == NULL)
    287613        return;
     614    mode_t mode = entry->Mode();
     615    BString perms;
     616   
     617    perms += (S_ISDIR(mode) ? "d" : "-");
     618    perms += ((mode & S_IRUSR) ? "r" : "-");
     619    perms += ((mode & S_IWUSR) ? "w" : "-");
     620    perms += ((mode & S_IXUSR) ? "x" : "-");
     621    perms += ((mode & S_IRGRP) ? "r" : "-");
     622    perms += ((mode & S_IWGRP) ? "w" : "-");
     623    perms += ((mode & S_IXGRP) ? "x" : "-");
     624    perms += ((mode & S_IROTH) ? "r" : "-");
     625    perms += ((mode & S_IWOTH) ? "w" : "-");
     626    perms += ((mode & S_IXOTH) ? "x" : "-");
     627   
     628    SetField(new BStringField(perms.String()), kPermissionsColumn);
     629}
    288630
    289 //  printf("PackageContentsView::SetPackage(%s)\n",
    290 //      package.Get() != NULL ? package->Title().String() : "NULL");
    291631
    292     Clear();
     632void
     633PackageEntryRow::UpdateLinkTargets()
     634{
     635    //TODO: Get link targets
     636    BString targets(Entry()->SymlinkPath());
     637    SetField(new BStringField(targets), kLinkTargetsColumn);
     638}
    293639
    294     {
    295         BAutolock lock(&fPackageLock);
    296         fPackage = package;
    297     }
    298     release_sem_etc(fContentPopulatorSem, 1, 0);
     640
     641void PackageEntryRow::SetBitmap(const BBitmap* bitmap)
     642{
     643    if(fTitle != NULL)
     644        fTitle->SetBitmap(bitmap);
    299645}
    300646
    301647
    302 void
    303 PackageContentsView::Clear()
     648// #pragma mark - private
     649
     650PackageEntryRow*
     651PackageContentsView::_FindRow(const PackageEntry* entry, PackageEntryRow* parent)
    304652{
    305     {
    306         BAutolock lock(&fPackageLock);
    307         fPackage.Unset();
     653    for (int32 i = CountRows(parent) - 1; i >= 0; i--) {
     654        PackageEntryRow* row = dynamic_cast<PackageEntryRow*>(RowAt(i, parent));
     655        if (row != NULL && row->Entry() == entry)
     656            return row;
     657        if (CountRows(row) > 0) {
     658            // recurse into child rows
     659            row = _FindRow(entry, row);
     660            if (row != NULL)
     661                return row;
     662        }
    308663    }
    309664
    310     fContentListView->MakeEmpty();
     665    return NULL;
    311666}
    312667
    313668
    314 // #pragma mark - private
     669PackageEntryRow*
     670PackageContentsView::_FindRow(const BString& packageTitle, PackageEntryRow* parent)
     671{
     672    for (int32 i = CountRows(parent) - 1; i >= 0; i--) {
     673        PackageEntryRow* row = dynamic_cast<PackageEntryRow*>(RowAt(i, parent));
     674        if (row != NULL && row->Entry() != NULL
     675            && row->Entry()->Name() == packageTitle) {
     676            return row;
     677        }
     678        if (CountRows(row) > 0) {
     679            // recurse into child rows
     680            row = _FindRow(packageTitle, row);
     681            if (row != NULL)
     682                return row;
     683        }
     684    }
    315685
     686    return NULL;
     687}
    316688
    317689void
    318690PackageContentsView::_InitContentPopulator()
    319691{
     692    printf("In _InitContentPopulator\n");
    320693    fContentPopulatorSem = create_sem(0, "PopulatePackageContents");
    321694    if (fContentPopulatorSem >= 0) {
    322695        fContentPopulator = spawn_thread(&_ContentPopulatorThread,
    323696            "Package Contents Populator", B_NORMAL_PRIORITY, this);
    324         if (fContentPopulator >= 0)
     697        if (fContentPopulator >= 0) {
    325698            resume_thread(fContentPopulator);
     699            printf("fContentPopulator resumed!");
     700        }
    326701    } else
    327702        fContentPopulator = -1;
    328703}
    PackageContentsView::_InitContentPopulator()  
    332707PackageContentsView::_ContentPopulatorThread(void* arg)
    333708{
    334709    PackageContentsView* view = reinterpret_cast<PackageContentsView*>(arg);
    335 
     710    printf("In _ContentPopulatorThread\n");
     711    if(view == NULL) {
     712        printf("_ContentPopulatorThread:: View null!\n");
     713        return 1;
     714    } else  printf("_ContentPopulatorThread:: View not null\n");
    336715    while (acquire_sem(view->fContentPopulatorSem) == B_OK) {
     716        printf("_ContentPopulatorThread: Acquiring sem");
    337717        PackageInfoRef package;
    338718        {
    339719            BAutolock lock(&view->fPackageLock);
    340720            package = view->fPackage;
    341721        }
    342 
    343722        if (package.Get() != NULL) {
    344             if (!view->_PopuplatePackageContens(*package.Get())) {
     723                printf("In _ContentPopulatorThread: Package not null\n");
     724            if (!view->_PopulatePackageContents(view, *package.Get())) {
    345725                if (view->LockLooper()) {
    346                     view->fContentListView->AddItem(
    347                         new BStringItem(B_TRANSLATE("<Package contents not "
    348                             "available for remote packages>")));
     726                        printf("In _ContentPopulatorThread:Remote package\n");
     727                    PackageEntryRow* notAvailable = new PackageEntryRow(
     728                        "<Package contents not available for remote packages>");
     729                    view->AddRow(notAvailable);
     730                    view->ExpandOrCollapse(notAvailable, true);
    349731                    view->UnlockLooper();
    350732                }
    351733            }
    352         }
     734        }else   printf("In _ContentPopulatorThread: package null\n");
    353735    }
    354 
    355736    return 0;
    356737}
    357738
    358739
    359740bool
    360 PackageContentsView::_PopuplatePackageContens(const PackageInfo& package)
     741PackageContentsView::_PopulatePackageContents(PackageContentsView* view,
     742                                    const PackageInfo& package)
    361743{
    362744    BPath packagePath;
    363 
     745    printf("In _PopulatePackageContents\n");
    364746    // Obtain path to the package file
    365747    if (package.IsLocalFile()) {
    366748        BString pathString = package.LocalFilePath();
    PackageContentsView::_PopuplatePackageContens(const PackageInfo& package)  
    378760                return false;
    379761            }
    380762        } else {
    381             printf("PackageContentsView::_PopuplatePackageContens(): "
     763            printf("PackageContentsView::_PopulatePackageContents(): "
    382764                "unknown install location");
    383765            return false;
    384766        }
    PackageContentsView::_PopuplatePackageContens(const PackageInfo& package)  
    399781    }
    400782
    401783    // Scan package contents and populate list
    402     PackageContentOutliner contentHandler(fContentListView, &package,
    403         fPackageLock, fPackage);
     784    PackageContentOutliner contentHandler( &package,
     785        fPackageLock, fPackage, packagePath, view);
    404786    status = reader.ParseContent(&contentHandler);
    405787    if (status != B_OK) {
    406788        printf("PackageContentsView::SetPackage(): "
    PackageContentsView::_InstallLocation(const PackageInfo& package) const  
    424806
    425807    return B_PACKAGE_INSTALLATION_LOCATION_SYSTEM;
    426808}
     809
     810
     811// #pragma mark - PackageContentsView
     812
     813
     814PackageContentsView::PackageContentsView()
     815    :
     816    BColumnListView("package contents view", 0, B_FANCY_BORDER, true),
     817    fPackageLock("package contents populator lock")
     818{
     819    AddColumn(new PackageEntryColumn(B_TRANSLATE("Name"), 375, 50, 400,
     820        B_TRUNCATE_MIDDLE), kTitleColumn);
     821    AddColumn(new PackageEntryColumn(B_TRANSLATE("Size"), 150, 50, 150,
     822        B_TRUNCATE_MIDDLE), kSizeColumn);
     823    AddColumn(new PackageEntryColumn(B_TRANSLATE("Permissions"), 100, 80, 100,
     824        B_TRUNCATE_MIDDLE), kPermissionsColumn);
     825    AddColumn(new PackageEntryColumn(B_TRANSLATE("Link Targets"), 300, 60, 400,
     826        B_TRUNCATE_END), kLinkTargetsColumn);
     827//  fItemCountView = new ItemCountView();
     828//  AddStatusView(fItemCountView);
     829    printf("Initializing population\n");
     830    _InitContentPopulator();
     831}
     832
     833
     834PackageContentsView::~PackageContentsView()
     835{
     836    Clear();
     837    delete_sem(fContentPopulatorSem);
     838    if (fContentPopulator >= 0)
     839        wait_for_thread(fContentPopulator, NULL);
     840}
     841
     842
     843void
     844PackageContentsView::AttachedToWindow()
     845{
     846    BColumnListView::AttachedToWindow();
     847    PackageEntryColumn::InitTextMargin(ScrollView());
     848}
     849
     850
     851void
     852PackageContentsView::AllAttached()
     853{
     854    BColumnListView::AllAttached();
     855
     856    SetSortingEnabled(true);
     857    SetSortColumn(ColumnAt(0), false, true);
     858}
     859
     860
     861void
     862PackageContentsView::MessageReceived(BMessage* message)
     863{
     864    switch (message->what) {
     865/*      case MSG_UPDATE_PACKAGE:
     866        {
     867            BString title;
     868            uint32 changes;
     869            if (message->FindString("title", &title) != B_OK
     870                || message->FindUInt32("changes", &changes) != B_OK) {
     871                break;
     872            }
     873
     874            PackageEntryRow* row = _FindRow(title);
     875            if (row != NULL) {
     876                if ((changes & PKG_CHANGED_SUMMARY) != 0)
     877                    row->UpdateTitle(row->PackageEntry());
     878                if ((changes & PKG_CHANGED_RATINGS) != 0)
     879                    row->UpdateSize(row->PackageEntry());
     880                if ((changes & PKG_CHANGED_STATE) != 0)
     881                    row->UpdatePermissions(row->PackageEntry());
     882                if ((changes & PKG_CHANGED_ICON) != 0)
     883                    row->UpdateLinkTargets(row->PackageEntry());
     884            }
     885            break;
     886        }
     887*/
     888        default:
     889            BColumnListView::MessageReceived(message);
     890            break;
     891    }
     892}
     893
     894
     895void
     896PackageContentsView::SelectionChanged()
     897{
     898    BColumnListView::SelectionChanged();
     899
     900    BMessage message(MSG_PACKAGE_SELECTED);
     901
     902    PackageEntryRow* selected = dynamic_cast<PackageEntryRow*>(CurrentSelection());
     903    if (selected != NULL)
     904        message.AddString("title", selected->Entry()->Name());
     905
     906    Window()->PostMessage(&message);
     907}
     908
     909
     910void
     911PackageContentsView::Clear()
     912{
     913//  fItemCountView->SetItemCount(0);
     914    BColumnListView::Clear();
     915    BAutolock lock(&fPackageLock);
     916    fPackage.Unset();
     917}
     918
     919
     920void
     921PackageContentsView::AddPackageEntry(const PackageEntry& package)
     922{
     923    PackageEntryRow* packageRow =(PackageEntryRow*) _FindRow(&package);
     924    printf("In AddPackageEntry: %s\n", package.Name());
     925    // forget about it if this package is already in the listview
     926    if (packageRow != NULL)
     927        return;
     928
     929    BAutolock _(fPackageLock);
     930
     931    // create the row for this package
     932    packageRow = new PackageEntryRow(&package);
     933
     934    // add the row, parent may be NULL (add at top level)
     935    AddRow(packageRow);
     936
     937    // make sure the row is initially expanded
     938    ExpandOrCollapse(packageRow, true);
     939
     940//  fItemCountView->SetItemCount(CountRows());
     941}
     942
     943
     944void
     945PackageContentsView::SelectPackageEntry(const PackageEntry* entry)
     946{
     947    PackageEntryRow* row = (PackageEntryRow*) _FindRow(entry);
     948    BRow* selected = CurrentSelection();
     949    if (row != selected)
     950        DeselectAll();
     951    if (row != NULL) {
     952        AddToSelection(row);
     953        SetFocusRow(row, false);
     954        ScrollTo(row);
     955    }
     956}
     957
     958
     959void
     960PackageContentsView::SetPackage(const PackageInfoRef& package)
     961{
     962if (fPackage == package)
     963        return;
     964
     965//  printf("PackageContentsView::SetPackage(%s)\n",
     966//      package.Get() != NULL ? package->Title().String() : "NULL");
     967
     968    Clear();
     969
     970    {
     971        BAutolock lock(&fPackageLock);
     972        fPackage = package;
     973    }
     974    release_sem_etc(fContentPopulatorSem, 1, 0);
     975}
     976
  • src/apps/haikudepot/ui/PackageContentsView.h

    diff --git a/src/apps/haikudepot/ui/PackageContentsView.h b/src/apps/haikudepot/ui/PackageContentsView.h
    index 2cd58a2..a83a26b 100644
    a b  
    11/*
    2  * Copyright 2015, TigerKid001.
     2 * Copyright 2015, Stephan Aßmus <superstippi@gmx.de>.
     3 * Copyright 2015, Sidhant Sharma <tigerkid001@gmail.com>.
    34 * All rights reserved. Distributed under the terms of the MIT License.
    45 */
     6
    57#ifndef PACKAGE_CONTENTS_VIEW_H
    68#define PACKAGE_CONTENTS_VIEW_H
    79
     10#include <ColumnListView.h>
     11#include <ColumnTypes.h>
    812#include <Locker.h>
    9 #include <View.h>
     13#include <package/hpkg/PackageEntry.h>
    1014
    1115#include "PackageInfo.h"
    1216
    13 class BOutlineListView;
     17using BPackageKit::BHPKG::BPackageEntry;
    1418
     19class PackageEntryRow;
     20class PackageEntry;
    1521
    16 class PackageContentsView : public BView {
     22class PackageContentsView : public BColumnListView {
    1723public:
    18                                 PackageContentsView(const char* name);
     24                                PackageContentsView();
    1925    virtual                     ~PackageContentsView();
    2026
    2127    virtual void                AttachedToWindow();
    2228    virtual void                AllAttached();
    2329
     30    void                            MessageReceived(BMessage*);
     31    virtual void                SelectionChanged();
     32
     33    virtual void                Clear();
     34   
     35            void                AddPackageEntry(const PackageEntry& package);
    2436            void                SetPackage(const PackageInfoRef& package);
    25             void                Clear();
     37
     38            void                SelectPackageEntry(const PackageEntry* entry);
    2639
    2740private:
     41            PackageEntryRow*            _FindRow(const PackageEntry* entry,
     42                                    PackageEntryRow* parent = NULL);
     43            PackageEntryRow*            _FindRow(const BString& packageTitle,
     44                                    PackageEntryRow* parent = NULL);
    2845            void                _InitContentPopulator();
    2946    static  int32               _ContentPopulatorThread(void* arg);
    30             bool                _PopuplatePackageContens(
    31                                     const PackageInfo& package);
     47            bool            _PopulatePackageContents(PackageContentsView* view,
     48                                            const PackageInfo& package);
    3249            int32               _InstallLocation(
    3350                                    const PackageInfo& package) const;
    3451
    3552private:
    36             BOutlineListView*   fContentListView;
    37 
     53//          class ItemCountView;
     54            friend class PackageContentOutliner;
    3855            thread_id           fContentPopulator;
    3956            sem_id              fContentPopulatorSem;
    4057            BLocker             fPackageLock;
    4158            PackageInfoRef      fPackage;
     59//          ItemCountView*      fItemCountView;
    4260};
    4361
    4462#endif // PACKAGE_CONTENTS_VIEW_H
  • src/apps/haikudepot/ui/PackageInfoView.cpp

    diff --git a/src/apps/haikudepot/ui/PackageInfoView.cpp b/src/apps/haikudepot/ui/PackageInfoView.cpp
    index 821406a..6b1dd24 100644
    a b public:  
    11781178        SetViewColor(tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
    11791179            kContentTint));
    11801180
    1181         fPackageContents = new PackageContentsView("contents_list");
     1181        fPackageContents = new PackageContentsView();
    11821182        AddChild(fPackageContents);
    11831183
    11841184    }