Ticket #13194: 0001-Suggested-changes-by-M.-Lotz.patch

File 0001-Suggested-changes-by-M.-Lotz.patch, 20.1 KB (added by perelandra, 8 years ago)

Without while changes

  • src/preferences/repositories/AddRepoWindow.cpp 

    From c6a3d1fc1f0150227dba76b54351b3381c938671 Mon Sep 17 00:00:00 2001
From: Brian Hill <supernova@warpmail.net>
Date: Sun, 8 Jan 2017 19:40:01 -0500
Subject: [PATCH 1/2] Suggested changes by M. Lotz

---
 src/preferences/repositories/AddRepoWindow.cpp     |  17 +--
 src/preferences/repositories/AddRepoWindow.h       |   3 +-
 .../repositories/RepositoriesSettings.h            |   5 +-
 src/preferences/repositories/RepositoriesView.cpp  | 115 ++++++++++++---------
 src/preferences/repositories/RepositoriesView.h    |  26 ++---
 .../repositories/RepositoriesWindow.cpp            |  26 +++--
 src/preferences/repositories/RepositoriesWindow.h  |   5 +-
 src/preferences/repositories/TaskLooper.cpp        |  21 ++--
 src/preferences/repositories/TaskLooper.h          |   3 +-
 src/preferences/repositories/TaskTimer.cpp         |  10 +-
 src/preferences/repositories/TaskTimer.h           |   3 +-
 11 files changed, 143 insertions(+), 91 deletions(-)

diff --git a/src/preferences/repositories/AddRepoWindow.cpp b/src/preferences/repositories/AddRepoWindow.cpp
index 1e0f325..b163ce5 100644
    a b  
    1414#include <Catalog.h>
    1515#include <Clipboard.h>
    1616#include <LayoutBuilder.h>
     17#include <Url.h>
    1718
    1819#include "constants.h"
    1920
    … … AddRepoWindow::MessageReceived(BMessage* message)  
    7677                Quit();
    7778            break;
    7879
    79         case ADD_BUTTON_PRESSED: {
     80        case ADD_BUTTON_PRESSED:
     81        {
    8082            BString url(fText->Text());
    8183            if (url != "") {
    8284                // URL must have a protocol
    83                 if (url.FindFirst("://") == B_ERROR) {
     85                BUrl newRepoUrl(url);
     86                if (!newRepoUrl.IsValid()) {
    8487                    BAlert* alert = new BAlert("error",
    85                         B_TRANSLATE_COMMENT("The URL must start with a "
    86                             "protocol, for example http:// or https://",
     88                        B_TRANSLATE_COMMENT("This is not a valid URL.",
    8789                            "Add URL error message"),
    8890                        kOKLabel, NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
    8991                    alert->SetFeel(B_MODAL_APP_WINDOW_FEEL);
    … … AddRepoWindow::MessageReceived(BMessage* message)  
    100102            }
    101103            break;
    102104        }
     105       
    103106        default:
    104107            BWindow::MessageReceived(message);
    105108    }
    … … AddRepoWindow::_GetClipboardData()  
    124127            &stringLen);
    125128        be_clipboard->Unlock();
    126129
    127         // The string must contain a web protocol
     130        // The string must be a valid url
    128131        BString clipString(string, stringLen);
    129         int32 ww = clipString.FindFirst("://");
    130         if (ww == B_ERROR)
     132        BUrl testUrl(clipString.String());
     133        if (!testUrl.IsValid())
    131134            return B_ERROR;
    132135        else
    133136            fText->SetText(clipString);

  • src/preferences/repositories/AddRepoWindow.h 

    diff --git a/src/preferences/repositories/AddRepoWindow.h b/src/preferences/repositories/AddRepoWindow.h
index c6c1758..6c128f3 100644
    a b public:  
    2424    virtual void            FrameResized(float newWidth, float newHeight);
    2525
    2626private:
     27    status_t                _GetClipboardData();
     28   
    2729    BTextControl*           fText;
    2830    BButton*                fAddButton;
    2931    BButton*                fCancelButton;
    3032    BMessenger              fReplyMessenger;
    31     status_t                _GetClipboardData();
    3233};
    3334
    3435

  • src/preferences/repositories/RepositoriesSettings.h 

    diff --git a/src/preferences/repositories/RepositoriesSettings.h b/src/preferences/repositories/RepositoriesSettings.h
index 8ceae1f..cea7a46 100644
    a b public:  
    2929                                BStringList& urlList);
    3030
    3131private:
     32    BMessage                _ReadFromFile();
     33    status_t                _SaveToFile(BMessage settings);
     34   
    3235    BPath                   fFilePath;
    3336    BFile                   fFile;
    3437    status_t                fInitStatus;
    35     BMessage                _ReadFromFile();
    36     status_t                _SaveToFile(BMessage settings);
    3738};
    3839
    3940

  • src/preferences/repositories/RepositoriesView.cpp 

    diff --git a/src/preferences/repositories/RepositoriesView.cpp b/src/preferences/repositories/RepositoriesView.cpp
index c1cd3cf..4e7788e 100644
    a b  
    1818#include <MessageRunner.h>
    1919#include <ScrollBar.h>
    2020#include <SeparatorView.h>
     21#include <Url.h>
    2122#include <package/PackageRoster.h>
    2223#include <package/RepositoryConfig.h>
    2324
    … … RepositoriesView::MessageReceived(BMessage* message)  
    224225{
    225226    switch (message->what)
    226227    {
    227         case REMOVE_REPOS: {
     228        case REMOVE_REPOS:
     229        {
    228230            RepoRow* rowItem = dynamic_cast<RepoRow*>(fListView->CurrentSelection());
    229231            if (!rowItem || !fRemoveButton->IsEnabled())
    230232                break;
    … … RepositoriesView::MessageReceived(BMessage* message)  
    272274            _SaveList();
    273275            break;
    274276        }
     277       
    275278        case LIST_SELECTION_CHANGED:
    276279            _UpdateButtons();
    277280            break;
    278281
    279         case ITEM_INVOKED: {
     282        case ITEM_INVOKED:
     283        {
    280284            // Simulates pressing whichever is the enabled button
    281285            if (fEnableButton->IsEnabled()) {
    282286                BMessage invokeMessage(ENABLE_BUTTON_PRESSED);
    … … RepositoriesView::MessageReceived(BMessage* message)  
    287291            }
    288292            break;
    289293        }
    290         case ENABLE_BUTTON_PRESSED: {
     294       
     295        case ENABLE_BUTTON_PRESSED:
     296        {
    291297            BStringList names;
    292298            bool paramsOK = true;
    293299            // Check if there are multiple selections of the same repository,
    … … RepositoriesView::MessageReceived(BMessage* message)  
    314320            }
    315321            break;
    316322        }
     323       
    317324        case DISABLE_BUTTON_PRESSED:
    318325            _AddSelectedRowsToQueue();
    319326            _UpdateButtons();
    320327            break;
    321328
    322         case TASK_STARTED: {
     329        case TASK_STARTED:
     330        {
    323331            int16 count;
    324332            status_t result1 = message->FindInt16(key_count, &count);
    325333            RepoRow* rowItem;
    … … RepositoriesView::MessageReceived(BMessage* message)  
    328336                _TaskStarted(rowItem, count);
    329337            break;
    330338        }
    331         case TASK_COMPLETED_WITH_ERRORS: {
     339       
     340        case TASK_COMPLETED_WITH_ERRORS:
     341        {
    332342            BString errorDetails;
    333343            status_t result = message->FindString(key_details, &errorDetails);
    334344            if (result == B_OK) {
    … … RepositoriesView::MessageReceived(BMessage* message)  
    350360            _UpdateButtons();
    351361            break;
    352362        }
    353         case TASK_COMPLETED: {
     363       
     364        case TASK_COMPLETED:
     365        {
    354366            BString repoName = message->GetString(key_name,
    355367                kNewRepoDefaultName.String());
    356368            int16 count;
    … … RepositoriesView::MessageReceived(BMessage* message)  
    367379            _UpdateButtons();
    368380            break;
    369381        }
    370         case TASK_CANCELED: {
     382       
     383        case TASK_CANCELED:
     384        {
    371385            int16 count;
    372386            status_t result1 = message->FindInt16(key_count, &count);
    373387            RepoRow* rowItem;
    … … RepositoriesView::MessageReceived(BMessage* message)  
    380394            _UpdateButtons();
    381395            break;
    382396        }
     397       
    383398        case UPDATE_LIST:
    384399            _RefreshList();
    385400            _UpdateButtons();
    386401            break;
    387402
    388         case STATUS_VIEW_COMPLETED_TIMEOUT: {
     403        case STATUS_VIEW_COMPLETED_TIMEOUT:
     404        {
    389405            int32 timerID;
    390406            status_t result = message->FindInt32(key_ID, &timerID);
    391407            if (result == B_OK && timerID == fLastCompletedTimerId)
    392408                _UpdateStatusView();
    393409            break;
    394410        }
     411       
    395412        default:
    396413            BView::MessageReceived(message);
    397414    }
    … … RepositoriesView::_TaskCompleted(RepoRow* rowItem, int16 count, BString& newName  
    434451    // Update row state and values
    435452    rowItem->SetTaskState(STATE_NOT_IN_QUEUE);
    436453    if (kNewRepoDefaultName.Compare(rowItem->Name()) == 0
    437         && newName.Compare("") != 0)
     454        && newName.Compare("") != 0) {
    438455        rowItem->SetName(newName.String());
     456    }
    439457    _UpdateFromRepoConfig(rowItem);
    440458}
    441459
    … … RepositoriesView::_UpdateFromRepoConfig(RepoRow* rowItem)  
    486504void
    487505RepositoriesView::AddManualRepository(BString url)
    488506{
     507    BUrl newRepoUrl(url);
     508    if (!newRepoUrl.IsValid())
     509        return;
     510   
    489511    BString name(kNewRepoDefaultName);
    490     BString rootUrl = _GetRootUrl(url);
    491     bool foundRoot = false;
     512    BString newPathIdentifier = _GetPathIdentifier(newRepoUrl.Path());
     513    bool foundMatchingRoot = false;
    492514    int32 index;
    493515    int32 listCount = fListView->CountRows();
    494516    for (index = 0; index < listCount; index++) {
    495517        RepoRow* repoItem = dynamic_cast<RepoRow*>(fListView->RowAt(index));
    496         const char* urlPtr = repoItem->Url();
     518        BUrl rowRepoUrl(repoItem->Url());
    497519        // Find an already existing URL
    498         if (url.ICompare(urlPtr) == 0) {
     520        if (newRepoUrl == rowRepoUrl) {
    499521            (new BAlert("duplicate",
    500522                B_TRANSLATE_COMMENT("This repository URL already exists.",
    501523                    "Error message"),
    502524                kOKLabel))->Go(NULL);
    503525            return;
    504526        }
    505         // Use the same name from another repo with the same root url
    506         if (foundRoot == false && rootUrl.ICompare(urlPtr,
    507                 rootUrl.Length()) == 0) {
    508             foundRoot = true;
    509             name = repoItem->Name();
     527        // Predict the repo name from another url with matching path root
     528        if (!foundMatchingRoot) {
     529            BString rowPathIdentifier = _GetPathIdentifier(rowRepoUrl.Path());
     530             if (newPathIdentifier.ICompare(rowPathIdentifier) == 0) {
     531                foundMatchingRoot = true;
     532                name = repoItem->Name();
     533             }
    510534        }
    511535    }
    512536    RepoRow* newRepo = _AddRepo(name, url, false);
    … … RepositoriesView::AddManualRepository(BString url)  
    519543
    520544
    521545BString
    522 RepositoriesView::_GetRootUrl(BString url)
     546RepositoriesView::_GetPathIdentifier(BString urlPath)
    523547{
    524     // Find the protocol if it exists
    525     int32 ww = url.FindFirst("://");
    526     if (ww == B_ERROR)
    527         ww = 0;
    528     else
    529         ww += 3;
    530548    // Find second /
    531     int32 rootEnd = url.FindFirst("/", ww + 1);
    532     if (rootEnd == B_ERROR)
    533         return url;
    534     rootEnd = url.FindFirst("/", rootEnd + 1);
    535     if (rootEnd == B_ERROR)
    536         return url;
     549    int32 index = urlPath.FindFirst("/");
     550    if (index == B_ERROR)
     551        return urlPath;
     552    index = urlPath.FindFirst("/", index + 1);
     553    if (index == B_ERROR)
     554        return urlPath;
    537555    else
    538         return url.Truncate(rootEnd);
     556        return urlPath.Truncate(index);
    539557}
    540558
    541559
    542560status_t
    543561RepositoriesView::_EmptyList()
    544562{
    545     BRow* row;
    546     while ((row = fListView->RowAt((int32)0, NULL)) != NULL) {
     563    BRow* row = fListView->RowAt((int32)0, NULL);
     564    while (row != NULL) {
    547565        fListView->RemoveRow(row);
    548566        delete row;
     567        row = fListView->RowAt((int32)0, NULL);
    549568    }
    550569    return B_OK;
    551570}
    … … RepositoriesView::_SaveList()  
    639658RepoRow*
    640659RepositoriesView::_AddRepo(BString name, BString url, bool enabled)
    641660{
    642     // URL must have a protocol
    643     if (url.FindFirst("://") == B_ERROR)
     661    // URL must be valid
     662    BUrl repoUrl(url);
     663    if (!repoUrl.IsValid())
    644664        return NULL;
    645     RepoRow* addedRow = NULL;
    646665    int32 index;
    647666    int32 listCount = fListView->CountRows();
    648667    // Find if the repo already exists in list
    649668    for (index = 0; index < listCount; index++) {
    650669        RepoRow* repoItem = dynamic_cast<RepoRow*>(fListView->RowAt(index));
    651         if (url.ICompare(repoItem->Url()) == 0) {
     670        BUrl itemUrl(repoItem->Url());
     671        if (repoUrl == itemUrl) {
    652672            // update name and enabled values
    653             if (name.Compare(repoItem->Name()) != 0)
     673            if (name != repoItem->Name())
    654674                repoItem->SetName(name.String());
    655675            repoItem->SetEnabled(enabled);
    656             addedRow = repoItem;
     676            return repoItem;
    657677        }
    658678    }
    659     if (addedRow == NULL) {
    660         addedRow = new RepoRow(name, url, enabled);
    661         fListView->AddRow(addedRow);
    662     }
     679    RepoRow* addedRow = new RepoRow(name, url, enabled);
     680    fListView->AddRow(addedRow);
    663681    return addedRow;
    664682}
    665683
    … … RepositoriesView::_UpdateButtons()  
    698716    RepoRow* rowItem = dynamic_cast<RepoRow*>(fListView->CurrentSelection());
    699717    // At least one row is selected
    700718    if (rowItem) {
    701         bool someAreEnabled = false,
    702             someAreDisabled = false,
    703             someAreInQueue = false;
     719        bool someAreEnabled = false;
     720        bool someAreDisabled = false;
     721        bool someAreInQueue = false;
    704722        int32 selectedCount = 0;
    705723        RepoRow* rowItem = dynamic_cast<RepoRow*>(fListView->CurrentSelection());
    706724        while (rowItem) {
    707725            selectedCount++;
    708726            uint32 taskState = rowItem->TaskState();
    709727            if ( taskState == STATE_IN_QUEUE_WAITING
    710                 || taskState == STATE_IN_QUEUE_RUNNING)
     728                || taskState == STATE_IN_QUEUE_RUNNING) {
    711729                someAreInQueue = true;
     730            }
    712731            if (rowItem->IsEnabled())
    713732                someAreEnabled = true;
    714733            else

  • src/preferences/repositories/RepositoriesView.h 

    diff --git a/src/preferences/repositories/RepositoriesView.h b/src/preferences/repositories/RepositoriesView.h
index 875b723..2bf5465 100644
    a b public:  
    3838    bool                    IsTaskRunning() { return fRunningTaskCount > 0; }
    3939
    4040private:
    41     RepositoriesSettings    fSettings;
    42     RepositoriesListView*   fListView;
    43     BView*                  fStatusContainerView;
    44     BStringView*            fListStatusView;
    45     TaskLooper*             fTaskLooper;
    46     bool                    fShowCompletedStatus;
    47     int                     fRunningTaskCount, fLastCompletedTimerId;
    48     BButton*                fAddButton;
    49     BButton*                fRemoveButton;
    50     BButton*                fEnableButton;
    51     BButton*                fDisableButton;
    52 
    5341    // Message helpers
    5442    void                    _AddSelectedRowsToQueue();
    5543    void                    _TaskStarted(RepoRow* rowItem, int16 count);
    … … private:  
    6048    void                    _UpdateFromRepoConfig(RepoRow* rowItem);
    6149
    6250    // GUI functions
    63     BString                 _GetRootUrl(BString url);
     51    BString                 _GetPathIdentifier(BString urlPath);
    6452    status_t                _EmptyList();
    6553    void                    _InitList();
    6654    void                    _RefreshList();
    … … private:  
    7058    void                    _FindSiblings();
    7159    void                    _UpdateButtons();
    7260    void                    _UpdateStatusView();
     61   
     62    RepositoriesSettings    fSettings;
     63    RepositoriesListView*   fListView;
     64    BView*                  fStatusContainerView;
     65    BStringView*            fListStatusView;
     66    TaskLooper*             fTaskLooper;
     67    bool                    fShowCompletedStatus;
     68    int                     fRunningTaskCount, fLastCompletedTimerId;
     69    BButton*                fAddButton;
     70    BButton*                fRemoveButton;
     71    BButton*                fEnableButton;
     72    BButton*                fDisableButton;
    7373};
    7474
    7575

  • src/preferences/repositories/RepositoriesWindow.cpp 

    diff --git a/src/preferences/repositories/RepositoriesWindow.cpp b/src/preferences/repositories/RepositoriesWindow.cpp
index 8087419..d2aad6c 100644
    a b RepositoriesWindow::RepositoriesWindow()  
    4343    BScreen screen;
    4444    BRect screenFrame = screen.Frame();
    4545    if (screenFrame.right < frame.right || screenFrame.left > frame.left
    46         || screenFrame.top > frame.top || screenFrame.bottom < frame.bottom)
     46        || screenFrame.top > frame.top || screenFrame.bottom < frame.bottom) {
    4747        CenterOnScreen();
     48    }
    4849    else
    4950        MoveTo(frame.left, frame.top);
    5051    Show();
    … … RepositoriesWindow::MessageReceived(BMessage* message)  
    126127{
    127128    switch (message->what)
    128129    {
    129         case ADD_REPO_WINDOW: {
     130        case ADD_REPO_WINDOW:
     131        {
    130132            BRect frame = Frame();
    131133            fAddWindow = new AddRepoWindow(frame, fMessenger);
    132134            break;
    133135        }
    134         case ADD_REPO_URL: {
     136       
     137        case ADD_REPO_URL:
     138        {
    135139            BString url;
    136140            status_t result = message->FindString(key_url, &url);
    137141            if (result == B_OK)
    138142                fView->AddManualRepository(url);
    139143            break;
    140144        }
    141         case ADD_WINDOW_CLOSED: {
     145       
     146        case ADD_WINDOW_CLOSED:
     147        {
    142148            fAddWindow = NULL;
    143149            break;
    144150        }
    145         case DELETE_KEY_PRESSED: {
     151       
     152        case DELETE_KEY_PRESSED:
     153        {
    146154            BMessage message(REMOVE_REPOS);
    147155            fView->MessageReceived(&message);
    148156            break;
    149157        }
     158       
    150159        // captures pkgman changes while the Repositories application is running
    151         case B_NODE_MONITOR: {
     160        case B_NODE_MONITOR:
     161        {
    152162            // This preflet is making the changes, so ignore this message
    153163            if (fView->IsTaskRunning())
    154164                break;
    … … RepositoriesWindow::MessageReceived(BMessage* message)  
    159169                {
    160170                    case B_ATTR_CHANGED:
    161171                    case B_ENTRY_CREATED:
    162                     case B_ENTRY_REMOVED: {
     172                    case B_ENTRY_REMOVED:
     173                    {
    163174                        PostMessage(UPDATE_LIST, fView);
    164175                        break;
    165176                    }
    … … RepositoriesWindow::MessageReceived(BMessage* message)  
    167178            }
    168179            break;
    169180        }
     181       
    170182        default:
    171183            BWindow::MessageReceived(message);
    172184    }

  • src/preferences/repositories/RepositoriesWindow.h 

    diff --git a/src/preferences/repositories/RepositoriesWindow.h b/src/preferences/repositories/RepositoriesWindow.h
index 3272bbf..6570c42 100644
    a b public:  
    2525    virtual void            MessageReceived(BMessage*);
    2626
    2727private:
     28    void                    _StartWatching();
     29    void                    _StopWatching();
     30   
    2831    RepositoriesSettings    fSettings;
    2932    RepositoriesView*       fView;
    3033    AddRepoWindow*          fAddWindow;
    … … private:  
    3437    status_t                fPackageNodeStatus;
    3538    bool                    fWatchingPackageNode;
    3639        // true when package-repositories directory is being watched
    37     void                    _StartWatching();
    38     void                    _StopWatching();
    3940};
    4041
    4142

  • src/preferences/repositories/TaskLooper.cpp 

    diff --git a/src/preferences/repositories/TaskLooper.cpp b/src/preferences/repositories/TaskLooper.cpp
index 91f9bf1..ef9fb3d 100644
    a b TaskLooper::MessageReceived(BMessage* message)  
    115115{
    116116    switch (message->what)
    117117    {
    118         case DO_TASK: {
     118        case DO_TASK:
     119        {
    119120            RepoRow* rowItem;
    120121            status_t result = message->FindPointer(key_rowptr, (void**)&rowItem);
    121122            if (result == B_OK) {
    … … TaskLooper::MessageReceived(BMessage* message)  
    170171            }
    171172            break;
    172173        }
     174       
    173175        case TASK_COMPLETED:
    174176        case TASK_COMPLETED_WITH_ERRORS:
    175         case TASK_CANCELED: {
     177        case TASK_CANCELED:
     178        {
    176179            Task* task;
    177180            status_t result = message->FindPointer(key_taskptr, (void**)&task);
    178181            if (result == B_OK && fTaskQueue.HasItem(task)) {
    … … TaskLooper::MessageReceived(BMessage* message)  
    183186                if (message->what == TASK_COMPLETED_WITH_ERRORS)
    184187                    reply.AddString(key_details, task->resultErrorDetails);
    185188                if (task->taskType == ENABLE_REPO
    186                     && task->name.Compare(task->resultName) != 0)
     189                    && task->name.Compare(task->resultName) != 0) {
    187190                    reply.AddString(key_name, task->resultName);
     191                }
    188192                fReplyTarget.SendMessage(&reply);
    189193                _RemoveAndDelete(task);
    190194            }
    191195            break;
    192196        }
    193         case TASK_KILL_REQUEST: {
     197       
     198        case TASK_KILL_REQUEST:
     199        {
    194200            Task* task;
    195201            status_t result = message->FindPointer(key_taskptr, (void**)&task);
    196202            if (result == B_OK && fTaskQueue.HasItem(task)) {
    … … TaskLooper::_DoTask(void* data)  
    230236    JobStateListener listener;
    231237    switch (task->taskType)
    232238    {
    233         case DISABLE_REPO: {
     239        case DISABLE_REPO:
     240        {
    234241            BString nameParam(task->taskParam);
    235242            BPackageKit::BContext context(decisionProvider, listener);
    236243            BPackageKit::DropRepositoryRequest dropRequest(context, nameParam);
    … … TaskLooper::_DoTask(void* data)  
    249256            }
    250257            break;
    251258        }
    252         case ENABLE_REPO: {
     259       
     260        case ENABLE_REPO:
     261        {
    253262            BString urlParam(task->taskParam);
    254263            BPackageKit::BContext context(decisionProvider, listener);
    255264            // Add repository

  • src/preferences/repositories/TaskLooper.h 

    diff --git a/src/preferences/repositories/TaskLooper.h b/src/preferences/repositories/TaskLooper.h
index 1a671e6..a79ab83 100644
    a b public:  
    5454    virtual void            MessageReceived(BMessage*);
    5555
    5656private:
    57     BObjectList<Task>       fTaskQueue;
    5857    void                    _RemoveAndDelete(Task* task);
    5958    static status_t         _DoTask(void* data);
    6059    static void             _AppendErrorDetails(BString& details,
    6160                                JobStateListener* listener);
     61   
     62    BObjectList<Task>       fTaskQueue;
    6263    BMessenger              fReplyTarget;
    6364    BMessenger              fMessenger;
    6465};

  • src/preferences/repositories/TaskTimer.cpp 

    diff --git a/src/preferences/repositories/TaskTimer.cpp b/src/preferences/repositories/TaskTimer.cpp
index 44b3a99..f13a748 100644
    a b TaskTimer::MessageReceived(BMessage* message)  
    6565{
    6666    switch (message->what)
    6767    {
    68         case TASK_TIMEOUT: {
     68        case TASK_TIMEOUT:
     69        {
    6970            fMessageRunner = NULL;
    7071            if (fTimerIsRunning) {
    7172                BString text(B_TRANSLATE_COMMENT("The task for repository"
    … … TaskTimer::MessageReceived(BMessage* message)  
    9495            }
    9596            break;
    9697        }
    97         case TIMEOUT_ALERT_BUTTON_SELECTION: {
     98       
     99        case TIMEOUT_ALERT_BUTTON_SELECTION:
     100        {
    98101            fTimeoutAlert = NULL;
    99102            // Timeout alert was invoked by user and timer still has not
    100103            // been stopped
    … … TaskTimer::Start(const char* name)  
    126129
    127130    // Create a message runner that will send a TASK_TIMEOUT message if the
    128131    // timer is not stopped
    129     if (fMessageRunner == NULL)
     132    if (fMessageRunner == NULL) {
    130133        fMessageRunner = new BMessageRunner(fMessenger, &fTimeoutMessage,
    131134            fTimeoutMicroSeconds, 1);
     135    }
    132136    else
    133137        fMessageRunner->SetInterval(fTimeoutMicroSeconds);
    134138}

  • src/preferences/repositories/TaskTimer.h 

    diff --git a/src/preferences/repositories/TaskTimer.h b/src/preferences/repositories/TaskTimer.h
index 00c0fec..6da0873 100644
    a b public:  
    4444    void                    Stop(const char* name);
    4545
    4646private:
     47    int32                   _NextAlertStackCount();
     48   
    4749    int32                   fTimeoutMicroSeconds;
    4850    bool                    fTimerIsRunning;
    4951    BString                 fRepositoryName;
    … … private:  
    5456    BAlert*                 fTimeoutAlert;
    5557    BInvoker                fTimeoutAlertInvoker;
    5658    Task*                   fOwner;
    57     int32                   _NextAlertStackCount();
    5859};
    5960
    6061