Ticket #1006: ticket_1006.diff

File ticket_1006.diff, 25.4 KB (added by ekam, 9 years ago)
  • BackgroundsView.h

     
    44 *
    55 * Authors:
    66 *      Jerome Duval (jerome.duval@free.fr)
     7 *      Markku Hyppönen, make.hypponen@pp.inet.fi
    78 */
    89#ifndef BACKGROUNDS_VIEW_H
    910#define BACKGROUNDS_VIEW_H
     
    4041
    4142class BGImageMenuItem : public BMenuItem {
    4243public:
    43                             BGImageMenuItem(const char* label, int32 imageIndex,
    44                                 BMessage* message, char shortcut = 0,
    45                                 uint32 modifiers = 0);
     44                                BGImageMenuItem(const char* label,
     45                                    int32 imageIndex, BMessage* message,
     46                                    char shortcut = 0, uint32 modifiers = 0);
     47            int32               ImageIndex() { return fImageIndex; }
    4648
    47             int32           ImageIndex() { return fImageIndex; }
    48 
    4949private:
    50             int32           fImageIndex;
     50            int32               fImageIndex;
    5151};
    5252
    5353
     
    6565
    6666class FramePart : public BView {
    6767public:
    68                             FramePart(int32 part);
     68                                FramePart(int32 part);
     69    virtual void                Draw(BRect rect);
     70            void                SetDesktop(bool isDesktop);
    6971
    70             void            Draw(BRect rect);
    71             void            SetDesktop(bool isDesktop);
    72 
    7372private:
    74             void            _SetSizeAndAlignment();
     73            void                _SetSizeAndAlignment();
    7574
    76             int32           fFramePart;
    77             bool            fIsDesktop;
     75            int32               fFramePart;
     76            bool                fIsDesktop;
    7877};
    7978
    8079
    8180class PreView : public BControl {
    8281public:
    83                             PreView();
     82                                PreView();
    8483
    85             BPoint          fPoint;
    86             BRect           fImageBounds;
     84            BPoint              fPoint;
     85            BRect               fImageBounds;
    8786
    8887protected:
    89             void            MouseDown(BPoint point);
    90             void            MouseUp(BPoint point);
    91             void            MouseMoved(BPoint point, uint32 transit,
     88    virtual void                MouseDown(BPoint point);
     89    virtual void                MouseUp(BPoint point);
     90    virtual void                MouseMoved(BPoint point, uint32 transit,
    9291                                const BMessage* message);
    93             void            AttachedToWindow();
     92    virtual void                AttachedToWindow();
    9493
    95             BPoint          fOldPoint;
    96             float           fXRatio;
    97             float           fYRatio;
    98             display_mode    fMode;
    99 
    100             BCursor         fMoveHandCursor;
     94            BPoint              fOldPoint;
     95            float               fXRatio;
     96            float               fYRatio;
     97            display_mode        fMode;
     98            BCursor             fMoveHandCursor;
    10199};
    102100
    103101
    104 class BackgroundsView : public BBox {
     102class Settings {
    105103public:
    106                             BackgroundsView();
    107                             ~BackgroundsView();
     104                                Settings();
    108105
    109             void            AllAttached();
    110             void            MessageReceived(BMessage* msg);
     106            int32               fWorkspace;
     107            BackgroundImage*    fImage;
     108            BackgroundImage::BackgroundImageInfo* fInfo;
     109            rgb_color           fColor;
     110            bool                fIsAllWorkspacesSelected;
    111111
    112             void            RefsReceived(BMessage* msg);
     112};
    113113
    114             void            SaveSettings();
    115             void            WorkspaceActivated(uint32 oldWorkspaces,
    116                                 bool active);
    117             int32           AddImage(BPath path);
    118             Image*          GetImage(int32 imageIndex);
     114class Controls {
     115public:
     116                                Controls();
    119117
    120             bool            FoundPositionSetting();
     118            int32               fWorkspace;
     119            rgb_color           fColor;
     120            bool                fTextWidgetLabelOutline;
     121            int32               fImageIndex;
     122            int32               fPlacementIndex;
     123            float               fOffsetX;
     124            float               fOffsetY;
     125};
    121126
    122 protected:
    123             void            _Save();
    124             void            _NotifyServer();
    125             void            _LoadSettings();
    126             void            _LoadDesktopFolder();
    127             void            _LoadDefaultFolder();
    128             void            _LoadFolder(bool isDesktop);
    129             void            _LoadRecentFolder(BPath path);
    130             void            _UpdateWithCurrent();
    131             void            _UpdatePreview();
    132             void            _UpdateButtons();
    133             void            _SetDesktop(bool isDesktop);
    134             int32           _AddPath(BPath path);
    135127
    136     static  int32           _NotifyThread(void* data);
     128class BackgroundsView : public BBox {
     129public:
     130                                BackgroundsView();
     131                                ~BackgroundsView();
     132    virtual void                AllAttached();
     133    virtual void                MessageReceived(BMessage* msg);
     134            void                RefsReceived(BMessage* msg);
     135            void                SaveSettings();
     136            void                WorkspaceActivated(uint32 workspace,
     137                                    bool active);
     138            int32               AddImage(BPath path);
     139            Image*              GetImage(int32 imageIndex);
     140            bool                FoundPositionSetting();
    137141
     142protected:
     143            void                _Save();
     144            void                _Revert();
     145            void                _RevertTo(BackgroundImage*& image,
     146                                    BackgroundImage::BackgroundImageInfo*& info,
     147                                    rgb_color& color);
     148            void                _NotifyServer();
     149            void                _LoadSettings();
     150            void                _LoadDesktopFolder();
     151            void                _LoadDefaultFolder();
     152            void                _LoadFolder(bool isDesktop);
     153            void                _LoadRecentFolder(BPath path);
     154            void                _UpdateWithCurrent();
     155            void                _UpdatePreview();
     156            void                _UpdateButtons();
     157            void                _SetDesktop(bool isDesktop);
     158            int32               _AddPath(BPath path);
     159    static  int32               _NotifyThread(void* data);
    138160            BGImageMenuItem*    _FindImageItem(const int32 imageIndex);
     161            bool                _AddItem(BGImageMenuItem* item);
     162            BackgroundImage::Mode _FindPlacementMode();
     163            void                _SetInitialSettings();
     164            void                _SetControlSettings(int32 workspace);
     165            Settings*           _GetInitialSettings(int32 workspace);
     166            Controls*           _GetControlSettings(int32 workspace,
     167                                    bool remove);
     168            void                _ResetControlSettings();
    139169
    140             bool            _AddItem(BGImageMenuItem* item);
    141 
    142             BackgroundImage::Mode   _FindPlacementMode();
    143 
    144             BColorControl*  fPicker;
    145             BButton*        fApply;
    146             BButton*        fRevert;
    147             BCheckBox*      fIconLabelOutline;
    148             BMenu*          fPlacementMenu;
    149             BMenu*          fImageMenu;
    150             BMenu*          fWorkspaceMenu;
    151             BTextControl*   fXPlacementText;
    152             BTextControl*   fYPlacementText;
    153             PreView*        fPreView;
    154             BBox*           fPreview;
    155             BFilePanel*     fFolderPanel;
    156             ImageFilePanel* fPanel;
    157 
     170            BColorControl*      fPicker;
     171            BButton*            fApply;
     172            BButton*            fRevert;
     173            BCheckBox*          fIconLabelOutline;
     174            BMenu*              fPlacementMenu;
     175            BMenu*              fImageMenu;
     176            BMenu*              fWorkspaceMenu;
     177            BTextControl*       fXPlacementText;
     178            BTextControl*       fYPlacementText;
     179            PreView*            fPreView;
     180            BBox*               fPreview;
     181            BFilePanel*         fFolderPanel;
     182            ImageFilePanel*     fPanel;
    158183            BackgroundImage*    fCurrent;
    159 
    160             BackgroundImage::BackgroundImageInfo*   fCurrentInfo;
    161 
    162             entry_ref       fCurrentRef;
    163             int32           fLastImageIndex;
    164             int32           fLastWorkspaceIndex;
    165             BMessage        fSettings;
    166 
     184            BackgroundImage::BackgroundImageInfo* fCurrentInfo;
     185            entry_ref           fCurrentRef;
     186            int32               fLastImageIndex;
     187            int32               fLastWorkspaceIndex;
     188            BMessage            fSettings;
    167189            BObjectList<BPath>  fPathList;
    168190            BObjectList<Image>  fImageList;
    169 
    170             FramePart*      fTopLeft;
    171             FramePart*      fTop;
    172             FramePart*      fTopRight;
    173             FramePart*      fLeft;
    174             FramePart*      fRight;
    175             FramePart*      fBottomLeft;
    176             FramePart*      fBottom;
    177             FramePart*      fBottomRight;
    178 
    179             bool            fFoundPositionSetting;
     191            FramePart*          fTopLeft;
     192            FramePart*          fTop;
     193            FramePart*          fTopRight;
     194            FramePart*          fLeft;
     195            FramePart*          fRight;
     196            FramePart*          fBottomLeft;
     197            FramePart*          fBottom;
     198            FramePart*          fBottomRight;
     199            bool                fFoundPositionSetting;
     200            rgb_color           color;
     201            BObjectList<Settings>* fInitialSettings;
     202            BObjectList<Controls>* fControlSettings;
    180203};
    181204
    182205#endif  // BACKGROUNDS_VIEW_H
  • BackgroundsView.cpp

     
    66 *      Jerome Duval (jerome.duval@free.fr)
    77 *      Axel Dörfler, axeld@pinc-software.de
    88 *      Jonas Sundström, jonas@kirilla.se
     9 *      Markku Hyppönen, make.hypponen@pp.inet.fi
    910 */
    1011
    1112
     
    179180        B_TRANSLATE("Current workspace"),
    180181        new BMessage(kMsgCurrentWorkspace)));
    181182    menuItem->SetMarked(true);
    182     fLastWorkspaceIndex =
    183         fWorkspaceMenu->IndexOf(fWorkspaceMenu->FindMarked());
     183    fLastWorkspaceIndex = fWorkspaceMenu->IndexOf(fWorkspaceMenu->FindMarked());
    184184    fWorkspaceMenu->AddSeparatorItem();
    185185    fWorkspaceMenu->AddItem(new BMenuItem(B_TRANSLATE("Default folder"),
    186186        new BMessage(kMsgDefaultFolder)));
     
    333333
    334334
    335335void
    336 BackgroundsView::MessageReceived(BMessage* msg)
     336BackgroundsView::MessageReceived(BMessage* message)
    337337{
    338     switch (msg->what) {
     338    switch (message->what) {
    339339        case B_SIMPLE_DATA:
    340340        case B_REFS_RECEIVED:
    341             RefsReceived(msg);
     341            RefsReceived(message);
    342342            break;
    343343
    344344        case kMsgUpdatePreviewPlacement:
     
    354354        }
    355355
    356356        case kMsgManualPlacement:
    357             _UpdatePreview();
    358             _UpdateButtons();
    359             break;
    360 
     357        case kMsgUpdateColor:
     358        case kMsgImagePlacement:
    361359        case kMsgTilePlacement:
    362360        case kMsgScalePlacement:
    363361        case kMsgCenterPlacement:
     
    369367            _UpdateButtons();
    370368            break;
    371369
    372         case kMsgUpdateColor:
    373         case kMsgImagePlacement:
    374             _UpdatePreview();
    375             _UpdateButtons();
    376             break;
    377 
    378370        case kMsgCurrentWorkspace:
    379371        case kMsgAllWorkspaces:
    380372            fImageMenu->FindItem(kMsgNoImage)->SetLabel(B_TRANSLATE("None"));
     
    408400        {
    409401            PRINT(("cancel received\n"));
    410402            void* pointer;
    411             msg->FindPointer("source", &pointer);
     403            message->FindPointer("source", &pointer);
    412404            if (pointer == fPanel) {
    413405                if (fLastImageIndex >= 0)
    414406                    _FindImageItem(fLastImageIndex)->SetMarked(true);
     
    445437            _Save();
    446438
    447439            //_NotifyServer();
    448             thread_id notify_thread;
    449             notify_thread = spawn_thread(BackgroundsView::_NotifyThread,
     440            thread_id notifyThread;
     441            notifyThread = spawn_thread(BackgroundsView::_NotifyThread,
    450442                "notifyServer", B_NORMAL_PRIORITY, this);
    451             resume_thread(notify_thread);
     443            resume_thread(notifyThread);
    452444            _UpdateButtons();
    453445            break;
    454446        }
    455447        case kMsgRevertSettings:
    456             _UpdateWithCurrent();
     448            _Revert();
    457449            break;
    458450
    459451        default:
    460             BView::MessageReceived(msg);
     452            BView::MessageReceived(message);
    461453            break;
    462454    }
    463455}
     
    468460{
    469461    BPath path;
    470462    if (find_directory(B_DESKTOP_DIRECTORY, &path) == B_OK) {
    471         status_t err;
    472         err = get_ref_for_path(path.Path(), &fCurrentRef);
    473         if (err != B_OK)
     463        status_t error;
     464        error = get_ref_for_path(path.Path(), &fCurrentRef);
     465        if (error != B_OK)
    474466            printf("error in LoadDesktopSettings\n");
    475467        _LoadFolder(true);
    476468    }
     
    484476    if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) == B_OK) {
    485477        BString pathString = path.Path();
    486478        pathString << "/Tracker/DefaultFolderTemplate";
    487         status_t err;
    488         err = get_ref_for_path(pathString.String(), &fCurrentRef);
    489         if (err != B_OK)
     479        status_t error;
     480        error = get_ref_for_path(pathString.String(), &fCurrentRef);
     481        if (error != B_OK)
    490482            printf("error in LoadDefaultFolderSettings\n");
    491483        _LoadFolder(false);
    492484    }
     
    496488void
    497489BackgroundsView::_LoadRecentFolder(BPath path)
    498490{
    499     status_t err;
    500     err = get_ref_for_path(path.Path(), &fCurrentRef);
    501     if (err != B_OK)
     491    status_t error;
     492    error = get_ref_for_path(path.Path(), &fCurrentRef);
     493    if (error != B_OK)
    502494        printf("error in LoadRecentFolder\n");
    503495    _LoadFolder(false);
    504496}
    505497
    506498
     499Settings*
     500BackgroundsView::_GetInitialSettings(int32 workspace)
     501{
     502    for (int32 i=0; i < fInitialSettings->CountItems(); i++) {
     503        Settings* settings = (Settings*)fInitialSettings->ItemAt(i);
     504        if (settings != NULL && settings->fWorkspace == workspace)
     505            return settings;
     506    }
     507    return NULL;
     508}
     509
     510
     511Controls*
     512BackgroundsView::_GetControlSettings(int32 workspace, bool remove)
     513{
     514    if (fControlSettings == NULL)
     515        fControlSettings = new BObjectList<Controls>();
     516
     517    int32 count = fControlSettings->CountItems();
     518
     519    for (int32 i=0; i < count; i++) {
     520    Controls* controls = (Controls*)fControlSettings->ItemAt(i);
     521        if (controls != NULL && controls->fWorkspace == workspace) {
     522            if (remove)
     523                return fControlSettings->RemoveItemAt(i);
     524            else
     525                return controls;
     526        }           
     527    }
     528    return NULL;
     529}
     530
     531
    507532void
     533BackgroundsView::_SetInitialSettings()
     534{
     535    if (fInitialSettings == NULL)
     536        fInitialSettings = new BObjectList<Settings>();
     537
     538    if (_GetInitialSettings(current_workspace()) == NULL) {
     539        BNode node(&fCurrentRef);
     540        if (node.InitCheck() != B_OK)
     541            return;
     542
     543        Settings* settings = new Settings();
     544        settings->fWorkspace = current_workspace();
     545        settings->fColor = BScreen().DesktopColor();
     546        settings->fImage =
     547                BackgroundImage::GetBackgroundImage(&node, true, this);
     548        settings->fInfo = settings->fImage
     549                ->ImageInfoForWorkspace(current_workspace());
     550
     551        fInitialSettings->AddItem(settings);
     552    }
     553}
     554
     555void
     556BackgroundsView::_SetControlSettings(int32 workspace)
     557{
     558    if (fControlSettings == NULL)
     559        fControlSettings = new BObjectList<Controls>();
     560
     561    Controls* controls = _GetControlSettings(workspace, true);
     562
     563    if (controls != NULL)
     564        delete controls;
     565
     566    controls = new Controls();
     567    rgb_color color = fPicker->ValueAsColor();
     568
     569    controls->fWorkspace = workspace;
     570    controls->fColor = color;
     571    controls->fTextWidgetLabelOutline =
     572            fIconLabelOutline->Value() == B_CONTROL_ON;
     573    controls->fImageIndex = fImageMenu->IndexOf(fImageMenu->FindMarked());
     574    controls->fPlacementIndex =
     575            fPlacementMenu->IndexOf(fPlacementMenu->FindMarked());
     576    controls->fOffsetX = atoi(fXPlacementText->Text());
     577    controls->fOffsetY = atoi(fYPlacementText->Text());
     578   
     579    fControlSettings->AddItem(controls);
     580
     581
     582}
     583
     584void
     585BackgroundsView::_ResetControlSettings()
     586{
     587    if (!fControlSettings)
     588        return;
     589
     590    if (fWorkspaceMenu->IndexOf(fWorkspaceMenu->FindMarked()) == 0) {
     591        while (fControlSettings->CountItems() > 0) {
     592            delete fControlSettings->RemoveItemAt(0);
     593        }
     594    }
     595}
     596
     597void
    508598BackgroundsView::_LoadFolder(bool isDesktop)
    509599{
    510600    if (fCurrent) {
     
    513603    }
    514604
    515605    BNode node(&fCurrentRef);
    516     if (node.InitCheck() == B_OK)
     606    if (node.InitCheck() == B_OK) {
    517607        fCurrent = BackgroundImage::GetBackgroundImage(&node, isDesktop, this);
    518 
     608        _SetInitialSettings();
     609    }
    519610    _UpdateWithCurrent();
    520611}
    521612
     
    523614void
    524615BackgroundsView::_UpdateWithCurrent(void)
    525616{
    526     if (fCurrent == NULL)
     617    rgb_color color = BScreen().DesktopColor();
     618    _RevertTo(fCurrent,fCurrentInfo,color);
     619    _UpdatePreview();
     620    _UpdateButtons();
     621}
     622
     623
     624void
     625BackgroundsView::_Revert()
     626{
     627    Settings* bgInfo = (Settings*)_GetInitialSettings(current_workspace());
     628    _RevertTo(bgInfo->fImage,bgInfo->fInfo,bgInfo->fColor);
     629    _ResetControlSettings();
     630    _SetInitialSettings();
     631    _UpdatePreview();
     632    _UpdateButtons();
     633
     634    fRevert->SetEnabled(false);
     635}
     636
     637
     638void
     639BackgroundsView::_RevertTo(BackgroundImage*& image,
     640    BackgroundImage::BackgroundImageInfo*& info, rgb_color& color)
     641{
     642    if (image == NULL)
    527643        return;
    528644
    529645    fPlacementMenu->FindItem(kMsgScalePlacement)
    530         ->SetEnabled(fCurrent->IsDesktop());
     646        ->SetEnabled(image->IsDesktop());
    531647    fPlacementMenu->FindItem(kMsgCenterPlacement)
    532         ->SetEnabled(fCurrent->IsDesktop());
     648        ->SetEnabled(image->IsDesktop());
    533649
    534650    if (fWorkspaceMenu->IndexOf(fWorkspaceMenu->FindMarked()) > 5)
    535651        fImageMenu->FindItem(kMsgNoImage)->SetLabel(B_TRANSLATE("Default"));
     
    546662    }
    547663
    548664    fImageMenu->SetTargetForItems(this);
     665       
     666    info = image->ImageInfoForWorkspace(current_workspace());
    549667
    550     fCurrentInfo = fCurrent->ImageInfoForWorkspace(current_workspace());
    551 
    552     if (!fCurrentInfo) {
     668    if (!info) {
    553669        fImageMenu->FindItem(kMsgNoImage)->SetMarked(true);
    554670        fPlacementMenu->FindItem(kMsgManualPlacement)->SetMarked(true);
    555671        fIconLabelOutline->SetValue(B_CONTROL_ON);
    556672    } else {
    557         fIconLabelOutline->SetValue(fCurrentInfo->fTextWidgetLabelOutline
     673        fIconLabelOutline->SetValue(info->fTextWidgetLabelOutline
    558674            ? B_CONTROL_ON : B_CONTROL_OFF);
    559675
    560         fLastImageIndex = fCurrentInfo->fImageIndex;
     676        fLastImageIndex = info->fImageIndex;
    561677        _FindImageItem(fLastImageIndex)->SetMarked(true);
    562678
    563679        if (fLastImageIndex > -1) {
    564 
    565680            BString xtext, ytext;
    566681            int32 cmd = 0;
    567             switch (fCurrentInfo->fMode) {
     682            switch (info->fMode) {
    568683                case BackgroundImage::kCentered:
    569684                    cmd = kMsgCenterPlacement;
    570685                    break;
     686
    571687                case BackgroundImage::kScaledToFit:
    572688                    cmd = kMsgScalePlacement;
    573689                    break;
     690
    574691                case BackgroundImage::kAtOffset:
    575692                    cmd = kMsgManualPlacement;
    576                     xtext << (int)fCurrentInfo->fOffset.x;
    577                     ytext << (int)fCurrentInfo->fOffset.y;
     693                    xtext << (int)info->fOffset.x;
     694                    ytext << (int)info->fOffset.y;
    578695                    break;
     696
    579697                case BackgroundImage::kTiled:
    580698                    cmd = kMsgTilePlacement;
    581699                    break;
     
    591709        }
    592710    }
    593711
    594     rgb_color color = {255, 255, 255, 255};
    595     if (fCurrent->IsDesktop()) {
    596         color = BScreen().DesktopColor();
    597         fPicker->SetEnabled(true);
    598     } else
    599         fPicker->SetEnabled(false);
    600 
     712    fPicker->SetEnabled(true);
    601713    fPicker->SetValue(color);
    602 
    603     _UpdatePreview();
    604     _UpdateButtons();
    605714}
    606715
    607716
    608717void
    609718BackgroundsView::_Save()
    610719{
    611     bool textWidgetLabelOutline
    612         = fIconLabelOutline->Value() == B_CONTROL_ON;
    613 
     720    bool textWidgetLabelOutline = fIconLabelOutline->Value() == B_CONTROL_ON;
    614721    BackgroundImage::Mode mode = _FindPlacementMode();
    615722    BPoint offset(atoi(fXPlacementText->Text()), atoi(fYPlacementText->Text()));
    616723
     
    637744            if (fWorkspaceMenu->FindItem(kMsgCurrentWorkspace)->IsMarked()) {
    638745                if (fCurrentInfo->fWorkspace & workspaceMask
    639746                    && fCurrentInfo->fWorkspace != workspaceMask) {
    640                     fCurrentInfo->fWorkspace = fCurrentInfo->fWorkspace
    641                         ^ workspaceMask;
     747                    fCurrentInfo->fWorkspace =
     748                        fCurrentInfo->fWorkspace ^ workspaceMask;
    642749                    fCurrentInfo = new BackgroundImage::BackgroundImageInfo(
    643750                        workspaceMask, fLastImageIndex, mode, offset,
    644751                        textWidgetLabelOutline, fCurrentInfo->fImageSet,
     
    704811    } else {
    705812        int32 i = -1;
    706813        BMessage reply;
    707         int32 err;
     814        int32 error;
    708815        BEntry currentEntry(&fCurrentRef);
    709816        BPath currentPath(&currentEntry);
    710817        bool isCustomFolder
    711818            = !fWorkspaceMenu->FindItem(kMsgDefaultFolder)->IsMarked();
    712819
    713820        do {
    714             BMessage msg(B_GET_PROPERTY);
     821            BMessage message = B_GET_PROPERTY;
    715822            i++;
    716823
    717824            // look at the "Poses" in every Tracker window
    718             msg.AddSpecifier("Poses");
    719             msg.AddSpecifier("Window", i);
     825            message.AddSpecifier("Poses");
     826            message.AddSpecifier("Window", i);
    720827
    721828            reply.MakeEmpty();
    722             tracker.SendMessage(&msg, &reply);
     829            tracker.SendMessage(&message, &reply);
    723830
    724831            // break out of the loop when we're at the end of
    725832            // the windows
    726833            if (reply.what == B_MESSAGE_NOT_UNDERSTOOD
    727                 && reply.FindInt32("error", &err) == B_OK
    728                 && err == B_BAD_INDEX)
     834                && reply.FindInt32("error", &error) == B_OK
     835                && error == B_BAD_INDEX)
    729836                break;
    730837
    731838            // don't stop for windows that don't understand
    732839            // a request for "Poses"; they're not displaying
    733840            // folders
    734841            if (reply.what == B_MESSAGE_NOT_UNDERSTOOD
    735                 && reply.FindInt32("error", &err) == B_OK
    736                 && err != B_BAD_SCRIPT_SYNTAX)
     842                && reply.FindInt32("error", &error) == B_OK
     843                && error != B_BAD_SCRIPT_SYNTAX)
    737844                continue;
    738845
    739846            BMessenger trackerWindow;
     
    742849
    743850            if (isCustomFolder) {
    744851                // found a window with poses, ask for its path
    745                 msg.MakeEmpty();
    746                 msg.what = B_GET_PROPERTY;
    747                 msg.AddSpecifier("Path");
    748                 msg.AddSpecifier("Poses");
    749                 msg.AddSpecifier("Window", i);
     852                message.MakeEmpty();
     853                message.what = B_GET_PROPERTY;
     854                message.AddSpecifier("Path");
     855                message.AddSpecifier("Poses");
     856                message.AddSpecifier("Window", i);
    750857
    751858                reply.MakeEmpty();
    752                 tracker.SendMessage(&msg, &reply);
     859                tracker.SendMessage(&message, &reply);
    753860
    754861                // go on with the next if this din't have a path
    755862                if (reply.what == B_MESSAGE_NOT_UNDERSTOOD)
     
    854961
    855962        path.SetTo(string.String());
    856963        int32 i = _AddPath(path);
    857         BString s;
    858         s << B_TRANSLATE("Folder: ") << path.Leaf();
    859         BMenuItem* item = new BMenuItem(s.String(),
     964        BString title;
     965        title << B_TRANSLATE("Folder: ") << path.Leaf();
     966        BMenuItem* item = new BMenuItem(title.String(),
    860967            new BMessage(kMsgFolderSelected));
    861968        fWorkspaceMenu->AddItem(item, -i - 1 + 6);
    862969        index++;
     
    868975
    869976
    870977void
    871 BackgroundsView::WorkspaceActivated(uint32 oldWorkspaces, bool active)
     978BackgroundsView::WorkspaceActivated(uint32 workspace, bool active)
    872979{
     980    rgb_color color = fPicker->ValueAsColor();
     981
     982    if ((int)workspace == current_workspace()) {       
     983        return;
     984    } else {
     985        _SetControlSettings(workspace);
     986    }
     987
     988    _SetInitialSettings();
    873989    _UpdateWithCurrent();
     990    _UpdatePreview();
     991
     992    Controls* controls =
     993            (Controls*)_GetControlSettings(current_workspace(),false);
     994
     995    if (controls != NULL) {
     996        fPicker->SetValue(controls->fColor);
     997        fIconLabelOutline->SetValue(controls->fTextWidgetLabelOutline ?
     998            B_CONTROL_ON : B_CONTROL_OFF);
     999
     1000        fImageMenu->ItemAt(controls->fImageIndex)->SetMarked(true);
     1001        fPlacementMenu->ItemAt(controls->fPlacementIndex)->SetMarked(true);
     1002       
     1003        BString xtext, ytext;
     1004        xtext << (int)controls->fOffsetX;
     1005        ytext << (int)controls->fOffsetY;
     1006        fXPlacementText->SetText(xtext);
     1007        fYPlacementText->SetText(ytext);
     1008
     1009        _UpdateButtons();
     1010        _UpdatePreview();
     1011    }
    8741012}
    8751013
    8761014
     
    8861024        && imageEnabled;
    8871025    if (fXPlacementText->IsEnabled() ^ textEnabled)
    8881026        fXPlacementText->SetEnabled(textEnabled);
     1027
    8891028    if (fYPlacementText->IsEnabled() ^ textEnabled)
    8901029        fYPlacementText->SetEnabled(textEnabled);
    8911030
     
    9391078
    9401079    if (fPlacementMenu->FindItem(kMsgCenterPlacement)->IsMarked())
    9411080        mode = BackgroundImage::kCentered;
     1081
    9421082    if (fPlacementMenu->FindItem(kMsgScalePlacement)->IsMarked())
    9431083        mode = BackgroundImage::kScaledToFit;
     1084
    9441085    if (fPlacementMenu->FindItem(kMsgManualPlacement)->IsMarked())
    9451086        mode = BackgroundImage::kAtOffset;
     1087
    9461088    if (fPlacementMenu->FindItem(kMsgTilePlacement)->IsMarked())
    9471089        mode = BackgroundImage::kTiled;
    9481090
     
    9531095void
    9541096BackgroundsView::_UpdateButtons()
    9551097{
    956     bool hasChanged = false;
     1098    Settings* initialSettings =
     1099            (Settings*)_GetInitialSettings(current_workspace());
     1100
     1101    if (initialSettings == NULL) {
     1102        return;
     1103    }
     1104
     1105    BackgroundImage* image = initialSettings->fImage;
     1106    BackgroundImage::BackgroundImageInfo* info = initialSettings->fInfo;
     1107    rgb_color color = initialSettings->fColor;
     1108    bool differsFromInitial = false;
     1109    bool differsFromControls = false;
     1110
    9571111    if (fPicker->IsEnabled()
    9581112        && fPicker->ValueAsColor() != BScreen().DesktopColor()) {
    959         hasChanged = true;
     1113        differsFromControls = true;
    9601114    } else if (fCurrentInfo) {
    9611115        if ((fIconLabelOutline->Value() == B_CONTROL_ON)
    9621116            ^ fCurrentInfo->fTextWidgetLabelOutline) {
    963             hasChanged = true;
     1117            differsFromControls = true;
    9641118        } else if (_FindPlacementMode() != fCurrentInfo->fMode) {
    965             hasChanged = true;
     1119            differsFromControls = true;
    9661120        } else if (fCurrentInfo->fImageIndex
    9671121            != ((BGImageMenuItem*)fImageMenu->FindMarked())->ImageIndex()) {
    968             hasChanged = true;
    969         } else if (fCurrent->IsDesktop()
     1122            differsFromControls = true;
     1123        } else if (image->IsDesktop()
    9701124            && ((fCurrentInfo->fWorkspace != B_ALL_WORKSPACES)
    9711125                ^ (fWorkspaceMenu->FindItem(kMsgCurrentWorkspace)->IsMarked())))
    9721126        {
    973             hasChanged = true;
     1127            differsFromControls = true;
    9741128        } else if (fCurrentInfo->fImageIndex > -1
    9751129            && fCurrentInfo->fMode == BackgroundImage::kAtOffset) {
    976             BString oldString, newString;
     1130            BString oldString;
    9771131            oldString << (int)fCurrentInfo->fOffset.x;
    9781132            if (oldString != BString(fXPlacementText->Text())) {
    979                 hasChanged = true;
     1133                differsFromControls = true;
    9801134            }
    9811135            oldString = "";
    9821136            oldString << (int)fCurrentInfo->fOffset.y;
    9831137            if (oldString != BString(fYPlacementText->Text())) {
    984                 hasChanged = true;
     1138                differsFromControls = true;
    9851139            }
    9861140        }
    987     } else if (fImageMenu->IndexOf(fImageMenu->FindMarked()) > 0) {
    988         hasChanged = true;
     1141    }
     1142
     1143    if (fPicker->IsEnabled()
     1144        && fPicker->ValueAsColor() != color) {
     1145        differsFromInitial = true;
     1146    } else if (info) {
     1147        if ((fIconLabelOutline->Value() == B_CONTROL_ON)
     1148            ^ info->fTextWidgetLabelOutline) {
     1149            differsFromInitial = true;
     1150        } else if (_FindPlacementMode() != info->fMode) {
     1151            differsFromInitial = true;
     1152        } else if (info->fImageIndex
     1153            != ((BGImageMenuItem*)fImageMenu->FindMarked())->ImageIndex()) {
     1154            differsFromInitial = true;
     1155        } else if (info->fImageIndex > -1
     1156            && info->fMode == BackgroundImage::kAtOffset) {
     1157            BString oldString;
     1158            oldString << (int)info->fOffset.x;
     1159            if (oldString != BString(fXPlacementText->Text())) {
     1160                differsFromInitial = true;
     1161            }
     1162            oldString = "";
     1163            oldString << (int)info->fOffset.y;
     1164            if (oldString != BString(fYPlacementText->Text())) {
     1165                differsFromInitial = true;
     1166            }
     1167        }
     1168    } else if (fImageMenu->IndexOf(fImageMenu->FindMarked())
     1169            != info->fImageIndex) {
     1170        differsFromInitial = true;
    9891171    } else if (fIconLabelOutline->Value() == B_CONTROL_OFF) {
    990         hasChanged = true;
     1172        differsFromInitial = true;
    9911173    }
    9921174
    993     fApply->SetEnabled(hasChanged);
    994     fRevert->SetEnabled(hasChanged);
     1175    fApply->SetEnabled(differsFromControls);
     1176    fRevert->SetEnabled(differsFromInitial);
    9951177}
    9961178
    9971179
    9981180void
    999 BackgroundsView::RefsReceived(BMessage* msg)
     1181BackgroundsView::RefsReceived(BMessage* message)
    10001182{
    1001     if (!msg->HasRef("refs") && msg->HasRef("dir_ref")) {
     1183    if (!message->HasRef("refs") && message->HasRef("dir_ref")) {
    10021184        entry_ref dirRef;
    1003         if (msg->FindRef("dir_ref", &dirRef) == B_OK)
    1004             msg->AddRef("refs", &dirRef);
     1185        if (message->FindRef("dir_ref", &dirRef) == B_OK)
     1186            message->AddRef("refs", &dirRef);
    10051187    }
    10061188
    10071189    entry_ref ref;
     
    10101192    BPath desktopPath;
    10111193    find_directory(B_DESKTOP_DIRECTORY, &desktopPath);
    10121194
    1013     while (msg->FindRef("refs", i++, &ref) == B_OK) {
     1195    while (message->FindRef("refs", i++, &ref) == B_OK) {
    10141196        BPath path;
    10151197        BEntry entry(&ref, true);
    10161198        path.SetTo(&entry);
     
    10381220
    10391221            // An optional placement may have been sent
    10401222            int32 placement = 0;
    1041             if (msg->FindInt32("placement", &placement) == B_OK) {
     1223            if (message->FindInt32("placement", &placement) == B_OK) {
    10421224                BMenuItem* item = fPlacementMenu->FindItem(placement);
    10431225                if (item)
    10441226                    item->SetMarked(true);
     
    10591241            } else {
    10601242                if (fWorkspaceMenu->CountItems() <= 5)
    10611243                    fWorkspaceMenu->AddSeparatorItem();
    1062                 BString s;
    1063                 s << B_TRANSLATE("Folder: ") << path.Leaf();
    1064                 item = new BMenuItem(s.String(),
     1244                BString title;
     1245                title << B_TRANSLATE("Folder: ") << path.Leaf();
     1246                item = new BMenuItem(title.String(),
    10651247                    new BMessage(kMsgFolderSelected));
    10661248                fWorkspaceMenu->AddItem(item, -index - 1 + 6);
    10671249                item->SetTarget(this);
     
    16461828    }
    16471829}
    16481830
     1831
     1832Settings::Settings()
     1833    :   
     1834    fImage(NULL),
     1835    fInfo(NULL),
     1836    fColor(rgb_color())
     1837{
     1838}
     1839
     1840
     1841Controls::Controls()
     1842    :
     1843    fColor(rgb_color())
     1844{
     1845}