Open Tracker License
Terms and Conditions
Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice applies to all licensees
and shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of Be Incorporated shall not be
used in advertising or otherwise to promote the sale, use or other dealings in
this Software without prior written authorization from Be Incorporated.
Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
of Be Incorporated in the United States and other countries. Other brand product
names are registered trademarks or trademarks of their respective holders.
All rights reserved.
*/
#include "SettingsViews.h"
#include <Box.h>
#include <Button.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <ColorControl.h>
#include <ControlLook.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <MenuField.h>
#include <NodeMonitor.h>
#include <Point.h>
#include <PopUpMenu.h>
#include <RadioButton.h>
#include <StringView.h>
#include "Commands.h"
#include "DeskWindow.h"
#include "Model.h"
#include "Tracker.h"
#include "TrackerDefaults.h"
#include "WidgetAttributeText.h"
static const uint32 kSpaceBarSwitchColor = 'SBsc';
static void
send_bool_notices(uint32 what, const char* name, bool value)
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
BMessage message;
message.AddBool(name, value);
tracker->SendNotices(what, &message);
}
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "SettingsView"
SettingsView::SettingsView(const char* name)
:
BGroupView(name)
{
}
SettingsView::~SettingsView()
{
}
The inherited functions should set the default values
and update the UI gadgets. The latter can by done by
calling ShowCurrentSettings().
*/
void
SettingsView::SetDefaults()
{
}
This function is used by the window to tell whether
it can ghost the defaults button or not. It doesn't
shows the default settings, this function should
return true.
*/
bool
SettingsView::IsDefaultable() const
{
return true;
}
The inherited functions should set the values that was
active when the settings window opened. It should also
update the UI widgets accordingly, preferrable by calling
ShowCurrentSettings().
*/
void
SettingsView::Revert()
{
}
This function is called when the window is shown to let
the settings views record the state to revert to.
*/
void
SettingsView::RecordRevertSettings()
{
}
This function is used by the window to tell the view
to display the current settings in the tracker.
*/
void
SettingsView::ShowCurrentSettings()
{
}
This function is used by the window to tell whether
it can ghost the revert button or not. It it shows the
reverted settings, this function should return true.
*/
bool
SettingsView::IsRevertable() const
{
return true;
}
DesktopSettingsView::DesktopSettingsView()
:
SettingsView("DesktopSettingsView"),
fShowDisksIconRadioButton(NULL),
fMountVolumesOntoDesktopRadioButton(NULL),
fMountSharedVolumesOntoDesktopCheckBox(NULL),
fShowDisksIcon(kDefaultShowDisksIcon),
fMountVolumesOntoDesktop(kDefaultMountVolumesOntoDesktop),
fMountSharedVolumesOntoDesktop(kDefaultMountSharedVolumesOntoDesktop),
fIntegrateNonBootBeOSDesktops(false),
fEjectWhenUnmounting(kDefaultEjectWhenUnmounting)
{
fShowDisksIconRadioButton = new BRadioButton("",
B_TRANSLATE("Show Disks icon"),
new BMessage(kShowDisksIconChanged));
fMountVolumesOntoDesktopRadioButton = new BRadioButton("",
B_TRANSLATE("Show volumes on Desktop"),
new BMessage(kVolumesOnDesktopChanged));
fMountSharedVolumesOntoDesktopCheckBox = new BCheckBox("",
B_TRANSLATE("Show shared volumes on Desktop"),
new BMessage(kVolumesOnDesktopChanged));
const float spacing = be_control_look->DefaultItemSpacing();
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.Add(fShowDisksIconRadioButton)
.Add(fMountVolumesOntoDesktopRadioButton)
.AddGroup(B_VERTICAL, 0)
.Add(fMountSharedVolumesOntoDesktopCheckBox)
.SetInsets(spacing * 2, 0, 0, 0)
.End()
.AddGlue()
.SetInsets(spacing);
}
void
DesktopSettingsView::AttachedToWindow()
{
fShowDisksIconRadioButton->SetTarget(this);
fMountVolumesOntoDesktopRadioButton->SetTarget(this);
fMountSharedVolumesOntoDesktopCheckBox->SetTarget(this);
}
void
DesktopSettingsView::MessageReceived(BMessage* message)
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
switch (message->what) {
case kShowDisksIconChanged:
{
fMountVolumesOntoDesktopRadioButton->SetValue(
!(fShowDisksIconRadioButton->Value() == 1));
fMountSharedVolumesOntoDesktopCheckBox->SetEnabled(
fMountVolumesOntoDesktopRadioButton->Value() == 1);
settings.SetShowDisksIcon(fShowDisksIconRadioButton->Value() == 1);
settings.SetMountVolumesOntoDesktop(
fMountVolumesOntoDesktopRadioButton->Value() == 1);
settings.SetMountSharedVolumesOntoDesktop(
fMountSharedVolumesOntoDesktopCheckBox->Value() == 1);
BMessage notificationMessage;
notificationMessage.AddBool("ShowDisksIcon",
fShowDisksIconRadioButton->Value() == 1);
notificationMessage.AddBool("MountVolumesOntoDesktop",
fMountVolumesOntoDesktopRadioButton->Value() == 1);
notificationMessage.AddBool("MountSharedVolumesOntoDesktop",
fMountSharedVolumesOntoDesktopCheckBox->Value() == 1);
tracker->SendNotices(kVolumesOnDesktopChanged,
¬ificationMessage);
Window()->PostMessage(kSettingsContentsModified);
break;
}
case kVolumesOnDesktopChanged:
{
fShowDisksIconRadioButton->SetValue(
!(fMountVolumesOntoDesktopRadioButton->Value() == 1));
fMountSharedVolumesOntoDesktopCheckBox->SetEnabled(
fMountVolumesOntoDesktopRadioButton->Value() == 1);
settings.SetShowDisksIcon(fShowDisksIconRadioButton->Value() == 1);
settings.SetMountVolumesOntoDesktop(
fMountVolumesOntoDesktopRadioButton->Value() == 1);
settings.SetMountSharedVolumesOntoDesktop(
fMountSharedVolumesOntoDesktopCheckBox->Value() == 1);
BMessage notificationMessage;
notificationMessage.AddBool("ShowDisksIcon",
fShowDisksIconRadioButton->Value() == 1);
notificationMessage.AddBool("MountVolumesOntoDesktop",
fMountVolumesOntoDesktopRadioButton->Value() == 1);
notificationMessage.AddBool("MountSharedVolumesOntoDesktop",
fMountSharedVolumesOntoDesktopCheckBox->Value() == 1);
tracker->SendNotices(kVolumesOnDesktopChanged, ¬ificationMessage);
Window()->PostMessage(kSettingsContentsModified);
break;
}
default:
_inherited::MessageReceived(message);
break;
}
}
void
DesktopSettingsView::SetDefaults()
{
TrackerSettings settings;
settings.SetShowDisksIcon(kDefaultShowDisksIcon);
settings.SetMountVolumesOntoDesktop(kDefaultMountVolumesOntoDesktop);
settings.SetMountSharedVolumesOntoDesktop(kDefaultMountSharedVolumesOntoDesktop);
settings.SetEjectWhenUnmounting(kDefaultEjectWhenUnmounting);
ShowCurrentSettings();
_SendNotices();
}
bool
DesktopSettingsView::IsDefaultable() const
{
TrackerSettings settings;
return settings.ShowDisksIcon() != kDefaultShowDisksIcon
|| settings.MountVolumesOntoDesktop() != kDefaultMountVolumesOntoDesktop
|| settings.MountSharedVolumesOntoDesktop() != kDefaultMountSharedVolumesOntoDesktop
|| settings.EjectWhenUnmounting() != kDefaultEjectWhenUnmounting;
}
void
DesktopSettingsView::Revert()
{
TrackerSettings settings;
settings.SetShowDisksIcon(fShowDisksIcon);
settings.SetMountVolumesOntoDesktop(fMountVolumesOntoDesktop);
settings.SetMountSharedVolumesOntoDesktop(fMountSharedVolumesOntoDesktop);
settings.SetEjectWhenUnmounting(fEjectWhenUnmounting);
ShowCurrentSettings();
_SendNotices();
}
void
DesktopSettingsView::_SendNotices()
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
BMessage notificationMessage;
notificationMessage.AddBool("ShowDisksIcon",
fShowDisksIconRadioButton->Value() == 1);
notificationMessage.AddBool("MountVolumesOntoDesktop",
fMountVolumesOntoDesktopRadioButton->Value() == 1);
notificationMessage.AddBool("MountSharedVolumesOntoDesktop",
fMountSharedVolumesOntoDesktopCheckBox->Value() == 1);
tracker->SendNotices(kVolumesOnDesktopChanged, ¬ificationMessage);
tracker->SendNotices(kDesktopIntegrationChanged, ¬ificationMessage);
}
void
DesktopSettingsView::ShowCurrentSettings()
{
TrackerSettings settings;
fShowDisksIconRadioButton->SetValue(settings.ShowDisksIcon());
fMountVolumesOntoDesktopRadioButton->SetValue(
settings.MountVolumesOntoDesktop());
fMountSharedVolumesOntoDesktopCheckBox->SetValue(
settings.MountSharedVolumesOntoDesktop());
fMountSharedVolumesOntoDesktopCheckBox->SetEnabled(
settings.MountVolumesOntoDesktop());
}
void
DesktopSettingsView::RecordRevertSettings()
{
TrackerSettings settings;
fShowDisksIcon = settings.ShowDisksIcon();
fMountVolumesOntoDesktop = settings.MountVolumesOntoDesktop();
fMountSharedVolumesOntoDesktop = settings.MountSharedVolumesOntoDesktop();
fEjectWhenUnmounting = settings.EjectWhenUnmounting();
}
bool
DesktopSettingsView::IsRevertable() const
{
return fShowDisksIcon != (fShowDisksIconRadioButton->Value() > 0)
|| fMountVolumesOntoDesktop !=
(fMountVolumesOntoDesktopRadioButton->Value() > 0)
|| fMountSharedVolumesOntoDesktop !=
(fMountSharedVolumesOntoDesktopCheckBox->Value() > 0);
}
WindowsSettingsView::WindowsSettingsView()
:
SettingsView("WindowsSettingsView"),
fShowFullPathInTitleBarCheckBox(NULL),
fSingleWindowBrowseCheckBox(NULL),
fShowNavigatorCheckBox(NULL),
fOutlineSelectionCheckBox(NULL),
fSortFolderNamesFirstCheckBox(NULL),
fHideDotFilesCheckBox(NULL),
fTypeAheadFilteringCheckBox(NULL),
fGenerateImageThumbnailsCheckBox(NULL),
fShowFullPathInTitleBar(kDefaultShowFullPathInTitleBar),
fSingleWindowBrowse(kDefaultSingleWindowBrowse),
fShowNavigator(kDefaultShowNavigator),
fTransparentSelection(kDefaultTransparentSelection),
fSortFolderNamesFirst(kDefaultSortFolderNamesFirst),
fHideDotFiles(kDefaultHideDotFiles),
fTypeAheadFiltering(kDefaultTypeAheadFiltering),
fGenerateImageThumbnails(kDefaultGenerateImageThumbnails)
{
fShowFullPathInTitleBarCheckBox = new BCheckBox("",
B_TRANSLATE("Show folder location in title tab"),
new BMessage(kWindowsShowFullPathChanged));
fSingleWindowBrowseCheckBox = new BCheckBox("",
B_TRANSLATE("Single window navigation"),
new BMessage(kSingleWindowBrowseChanged));
fShowNavigatorCheckBox = new BCheckBox("",
B_TRANSLATE("Show navigator"),
new BMessage(kShowNavigatorChanged));
fOutlineSelectionCheckBox = new BCheckBox("",
B_TRANSLATE("Outline selection rectangle only"),
new BMessage(kTransparentSelectionChanged));
fSortFolderNamesFirstCheckBox = new BCheckBox("",
B_TRANSLATE("List folders first"),
new BMessage(kSortFolderNamesFirstChanged));
fHideDotFilesCheckBox = new BCheckBox("",
B_TRANSLATE("Hide dotfiles"),
new BMessage(kHideDotFilesChanged));
fTypeAheadFilteringCheckBox = new BCheckBox("",
B_TRANSLATE("Enable type-ahead filtering"),
new BMessage(kTypeAheadFilteringChanged));
fGenerateImageThumbnailsCheckBox = new BCheckBox("",
B_TRANSLATE("Generate image thumbnails"),
new BMessage(kGenerateImageThumbnailsChanged));
const float spacing = be_control_look->DefaultItemSpacing();
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.AddGroup(B_VERTICAL, 0)
.Add(fShowFullPathInTitleBarCheckBox)
.Add(fSingleWindowBrowseCheckBox)
.End()
.AddGroup(B_VERTICAL)
.Add(fShowNavigatorCheckBox)
.SetInsets(spacing * 2, 0, 0, 0)
.End()
.AddGroup(B_VERTICAL, 0)
.Add(fOutlineSelectionCheckBox)
.Add(fSortFolderNamesFirstCheckBox)
.Add(fHideDotFilesCheckBox)
.Add(fTypeAheadFilteringCheckBox)
.Add(fGenerateImageThumbnailsCheckBox)
.End()
.AddGlue()
.SetInsets(spacing);
}
void
WindowsSettingsView::AttachedToWindow()
{
fSingleWindowBrowseCheckBox->SetTarget(this);
fShowNavigatorCheckBox->SetTarget(this);
fShowFullPathInTitleBarCheckBox->SetTarget(this);
fOutlineSelectionCheckBox->SetTarget(this);
fSortFolderNamesFirstCheckBox->SetTarget(this);
fHideDotFilesCheckBox->SetTarget(this);
fTypeAheadFilteringCheckBox->SetTarget(this);
fGenerateImageThumbnailsCheckBox->SetTarget(this);
}
void
WindowsSettingsView::MessageReceived(BMessage* message)
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
switch (message->what) {
case kWindowsShowFullPathChanged:
settings.SetShowFullPathInTitleBar(
fShowFullPathInTitleBarCheckBox->Value() == 1);
tracker->SendNotices(kWindowsShowFullPathChanged);
Window()->PostMessage(kSettingsContentsModified);
break;
case kSingleWindowBrowseChanged:
settings.SetSingleWindowBrowse(
fSingleWindowBrowseCheckBox->Value() == 1);
if (fSingleWindowBrowseCheckBox->Value() == 0) {
fShowNavigatorCheckBox->SetEnabled(false);
settings.SetShowNavigator(0);
} else {
fShowNavigatorCheckBox->SetEnabled(true);
settings.SetShowNavigator(
fShowNavigatorCheckBox->Value() != 0);
}
tracker->SendNotices(kShowNavigatorChanged);
tracker->SendNotices(kSingleWindowBrowseChanged);
Window()->PostMessage(kSettingsContentsModified);
break;
case kShowNavigatorChanged:
settings.SetShowNavigator(fShowNavigatorCheckBox->Value() == 1);
tracker->SendNotices(kShowNavigatorChanged);
Window()->PostMessage(kSettingsContentsModified);
break;
case kTransparentSelectionChanged:
{
settings.SetTransparentSelection(
fOutlineSelectionCheckBox->Value() == B_CONTROL_OFF);
send_bool_notices(kTransparentSelectionChanged,
"TransparentSelection", settings.TransparentSelection());
Window()->PostMessage(kSettingsContentsModified);
break;
}
case kSortFolderNamesFirstChanged:
{
settings.SetSortFolderNamesFirst(
fSortFolderNamesFirstCheckBox->Value() == 1);
send_bool_notices(kSortFolderNamesFirstChanged,
"SortFolderNamesFirst",
fSortFolderNamesFirstCheckBox->Value() == 1);
Window()->PostMessage(kSettingsContentsModified);
break;
}
case kHideDotFilesChanged:
{
settings.SetHideDotFiles(
fHideDotFilesCheckBox->Value() == 1);
send_bool_notices(kHideDotFilesChanged,
"HideDotFiles",
fHideDotFilesCheckBox->Value() == 1);
Window()->PostMessage(kSettingsContentsModified);
break;
}
case kTypeAheadFilteringChanged:
{
settings.SetTypeAheadFiltering(
fTypeAheadFilteringCheckBox->Value() == 1);
send_bool_notices(kTypeAheadFilteringChanged,
"TypeAheadFiltering",
fTypeAheadFilteringCheckBox->Value() == 1);
Window()->PostMessage(kSettingsContentsModified);
break;
}
case kGenerateImageThumbnailsChanged:
{
settings.SetGenerateImageThumbnails(
fGenerateImageThumbnailsCheckBox->Value() == 1);
send_bool_notices(kGenerateImageThumbnailsChanged,
"GenerateImageThumbnails",
fGenerateImageThumbnailsCheckBox->Value() == 1);
Window()->PostMessage(kSettingsContentsModified);
break;
}
default:
_inherited::MessageReceived(message);
break;
}
}
void
WindowsSettingsView::SetDefaults()
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
if (settings.ShowFullPathInTitleBar() != kDefaultShowFullPathInTitleBar) {
settings.SetShowFullPathInTitleBar(kDefaultShowFullPathInTitleBar);
tracker->SendNotices(kWindowsShowFullPathChanged);
}
if (settings.SingleWindowBrowse() != kDefaultSingleWindowBrowse) {
settings.SetSingleWindowBrowse(kDefaultSingleWindowBrowse);
tracker->SendNotices(kSingleWindowBrowseChanged);
}
if (settings.ShowNavigator() != kDefaultShowNavigator) {
settings.SetShowNavigator(kDefaultShowNavigator);
tracker->SendNotices(kShowNavigatorChanged);
}
if (settings.TransparentSelection() != kDefaultTransparentSelection) {
settings.SetTransparentSelection(kDefaultTransparentSelection);
send_bool_notices(kTransparentSelectionChanged,
"TransparentSelection", kDefaultTransparentSelection);
}
if (settings.SortFolderNamesFirst() != kDefaultSortFolderNamesFirst) {
settings.SetSortFolderNamesFirst(kDefaultSortFolderNamesFirst);
send_bool_notices(kSortFolderNamesFirstChanged,
"SortFolderNamesFirst", kDefaultSortFolderNamesFirst);
}
if (settings.HideDotFiles() != kDefaultHideDotFiles) {
settings.SetHideDotFiles(kDefaultHideDotFiles);
send_bool_notices(kHideDotFilesChanged,
"HideDotFiles", kDefaultHideDotFiles);
}
if (settings.TypeAheadFiltering() != kDefaultTypeAheadFiltering) {
settings.SetTypeAheadFiltering(kDefaultTypeAheadFiltering);
send_bool_notices(kTypeAheadFilteringChanged,
"TypeAheadFiltering", kDefaultTypeAheadFiltering);
}
if (settings.GenerateImageThumbnails() != kDefaultGenerateImageThumbnails) {
settings.SetGenerateImageThumbnails(kDefaultGenerateImageThumbnails);
send_bool_notices(kGenerateImageThumbnailsChanged,
"GenerateImageThumbnails", kDefaultGenerateImageThumbnails);
}
ShowCurrentSettings();
}
bool
WindowsSettingsView::IsDefaultable() const
{
TrackerSettings settings;
return settings.ShowFullPathInTitleBar() != kDefaultShowFullPathInTitleBar
|| settings.SingleWindowBrowse() != kDefaultSingleWindowBrowse
|| settings.ShowNavigator() != kDefaultShowNavigator
|| settings.TransparentSelection() != kDefaultTransparentSelection
|| settings.SortFolderNamesFirst() != kDefaultSortFolderNamesFirst
|| settings.HideDotFiles() != kDefaultHideDotFiles
|| settings.TypeAheadFiltering() != kDefaultTypeAheadFiltering
|| settings.GenerateImageThumbnails() != kDefaultGenerateImageThumbnails;
}
void
WindowsSettingsView::Revert()
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
if (settings.ShowFullPathInTitleBar() != fShowFullPathInTitleBar) {
settings.SetShowFullPathInTitleBar(fShowFullPathInTitleBar);
tracker->SendNotices(kWindowsShowFullPathChanged);
}
if (settings.SingleWindowBrowse() != fSingleWindowBrowse) {
settings.SetSingleWindowBrowse(fSingleWindowBrowse);
tracker->SendNotices(kSingleWindowBrowseChanged);
}
if (settings.ShowNavigator() != fShowNavigator) {
settings.SetShowNavigator(fShowNavigator);
tracker->SendNotices(kShowNavigatorChanged);
}
if (settings.TransparentSelection() != fTransparentSelection) {
settings.SetTransparentSelection(fTransparentSelection);
send_bool_notices(kTransparentSelectionChanged,
"TransparentSelection", fTransparentSelection);
}
if (settings.SortFolderNamesFirst() != fSortFolderNamesFirst) {
settings.SetSortFolderNamesFirst(fSortFolderNamesFirst);
send_bool_notices(kSortFolderNamesFirstChanged,
"SortFolderNamesFirst", fSortFolderNamesFirst);
}
if (settings.HideDotFiles() != fHideDotFiles) {
settings.SetSortFolderNamesFirst(fHideDotFiles);
send_bool_notices(kHideDotFilesChanged,
"HideDotFiles", fHideDotFiles);
}
if (settings.TypeAheadFiltering() != fTypeAheadFiltering) {
settings.SetTypeAheadFiltering(fTypeAheadFiltering);
send_bool_notices(kTypeAheadFilteringChanged,
"TypeAheadFiltering", fTypeAheadFiltering);
}
if (settings.GenerateImageThumbnails() != fGenerateImageThumbnails) {
settings.SetGenerateImageThumbnails(fGenerateImageThumbnails);
send_bool_notices(kGenerateImageThumbnailsChanged,
"GenerateImageThumbnails", fGenerateImageThumbnails);
}
ShowCurrentSettings();
}
void
WindowsSettingsView::ShowCurrentSettings()
{
TrackerSettings settings;
fShowFullPathInTitleBarCheckBox->SetValue(
settings.ShowFullPathInTitleBar());
fSingleWindowBrowseCheckBox->SetValue(settings.SingleWindowBrowse());
fShowNavigatorCheckBox->SetEnabled(settings.SingleWindowBrowse());
fShowNavigatorCheckBox->SetValue(settings.ShowNavigator());
fOutlineSelectionCheckBox->SetValue(settings.TransparentSelection()
? B_CONTROL_OFF : B_CONTROL_ON);
fSortFolderNamesFirstCheckBox->SetValue(settings.SortFolderNamesFirst());
fHideDotFilesCheckBox->SetValue(settings.HideDotFiles());
fTypeAheadFilteringCheckBox->SetValue(settings.TypeAheadFiltering());
fGenerateImageThumbnailsCheckBox->SetValue(
settings.GenerateImageThumbnails());
}
void
WindowsSettingsView::RecordRevertSettings()
{
TrackerSettings settings;
fShowFullPathInTitleBar = settings.ShowFullPathInTitleBar();
fSingleWindowBrowse = settings.SingleWindowBrowse();
fShowNavigator = settings.ShowNavigator();
fTransparentSelection = settings.TransparentSelection();
fSortFolderNamesFirst = settings.SortFolderNamesFirst();
fHideDotFiles = settings.HideDotFiles();
fTypeAheadFiltering = settings.TypeAheadFiltering();
fGenerateImageThumbnails = settings.GenerateImageThumbnails();
}
bool
WindowsSettingsView::IsRevertable() const
{
TrackerSettings settings;
return fShowFullPathInTitleBar != settings.ShowFullPathInTitleBar()
|| fSingleWindowBrowse != settings.SingleWindowBrowse()
|| fShowNavigator != settings.ShowNavigator()
|| fTransparentSelection != settings.TransparentSelection()
|| fSortFolderNamesFirst != settings.SortFolderNamesFirst()
|| fHideDotFiles != settings.HideDotFiles()
|| fTypeAheadFiltering != settings.TypeAheadFiltering()
|| fGenerateImageThumbnails != settings.GenerateImageThumbnails();
}
SpaceBarSettingsView::SpaceBarSettingsView()
:
SettingsView("SpaceBarSettingsView")
{
fSpaceBarShowCheckBox = new BCheckBox("",
B_TRANSLATE("Show space bars on volumes"),
new BMessage(kUpdateVolumeSpaceBar));
BPopUpMenu* menu = new BPopUpMenu(B_EMPTY_STRING);
menu->SetFont(be_plain_font);
BMenuItem* item;
menu->AddItem(item = new BMenuItem(
B_TRANSLATE("Used space color"),
new BMessage(kSpaceBarSwitchColor)));
item->SetMarked(true);
fCurrentColor = 0;
menu->AddItem(new BMenuItem(
B_TRANSLATE("Free space color"),
new BMessage(kSpaceBarSwitchColor)));
menu->AddItem(new BMenuItem(
B_TRANSLATE("Warning space color"),
new BMessage(kSpaceBarSwitchColor)));
fColorPicker = new BMenuField("menu", NULL, menu);
fColorControl = new BColorControl(BPoint(0, 0),
B_CELLS_16x16, 1, "SpaceColorControl",
new BMessage(kSpaceBarColorChanged));
fColorControl->SetValue(TrackerSettings().UsedSpaceColor());
BBox* box = new BBox("box");
box->SetLabel(fColorPicker);
box->AddChild(BLayoutBuilder::Group<>(B_HORIZONTAL)
.Add(fColorControl)
.SetInsets(B_USE_DEFAULT_SPACING)
.View());
BLayoutBuilder::Group<>(this, B_VERTICAL)
.Add(fSpaceBarShowCheckBox)
.Add(box)
.AddGlue()
.SetInsets(B_USE_DEFAULT_SPACING);
}
SpaceBarSettingsView::~SpaceBarSettingsView()
{
}
void
SpaceBarSettingsView::AttachedToWindow()
{
fSpaceBarShowCheckBox->SetTarget(this);
fColorControl->SetTarget(this);
fColorPicker->Menu()->SetTargetForItems(this);
}
void
SpaceBarSettingsView::MessageReceived(BMessage* message)
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
switch (message->what) {
case kUpdateVolumeSpaceBar:
{
settings.SetShowVolumeSpaceBar(
fSpaceBarShowCheckBox->Value() == 1);
Window()->PostMessage(kSettingsContentsModified);
tracker->PostMessage(kShowVolumeSpaceBar);
break;
}
case kSpaceBarSwitchColor:
{
fCurrentColor = message->FindInt32("index");
switch (fCurrentColor) {
case 0:
fColorControl->SetValue(settings.UsedSpaceColor());
break;
case 1:
fColorControl->SetValue(settings.FreeSpaceColor());
break;
case 2:
fColorControl->SetValue(settings.WarningSpaceColor());
break;
}
break;
}
case kSpaceBarColorChanged:
{
rgb_color color = fColorControl->ValueAsColor();
color.alpha = kDefaultSpaceBarAlpha;
switch (fCurrentColor) {
case 0:
settings.SetUsedSpaceColor(color);
break;
case 1:
settings.SetFreeSpaceColor(color);
break;
case 2:
settings.SetWarningSpaceColor(color);
break;
}
BWindow* window = Window();
if (window != NULL)
window->PostMessage(kSettingsContentsModified);
tracker->PostMessage(kSpaceBarColorChanged);
break;
}
default:
_inherited::MessageReceived(message);
break;
}
}
void
SpaceBarSettingsView::SetDefaults()
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
if (!settings.ShowVolumeSpaceBar()) {
settings.SetShowVolumeSpaceBar(true);
send_bool_notices(kShowVolumeSpaceBar, "ShowVolumeSpaceBar", kDefaultShowVolumeSpaceBar);
}
if (settings.UsedSpaceColor() != kDefaultUsedSpaceColor
|| settings.FreeSpaceColor() != kDefaultFreeSpaceColor
|| settings.WarningSpaceColor() != kDefaultWarningSpaceColor) {
settings.SetUsedSpaceColor(kDefaultUsedSpaceColor);
settings.SetFreeSpaceColor(kDefaultFreeSpaceColor);
settings.SetWarningSpaceColor(kDefaultWarningSpaceColor);
tracker->SendNotices(kSpaceBarColorChanged);
}
ShowCurrentSettings();
}
bool
SpaceBarSettingsView::IsDefaultable() const
{
TrackerSettings settings;
return settings.ShowVolumeSpaceBar() != kDefaultShowVolumeSpaceBar
|| settings.UsedSpaceColor() != kDefaultUsedSpaceColor
|| settings.FreeSpaceColor() != kDefaultFreeSpaceColor
|| settings.WarningSpaceColor() != kDefaultWarningSpaceColor;
}
void
SpaceBarSettingsView::Revert()
{
TTracker* tracker = dynamic_cast<TTracker*>(be_app);
if (tracker == NULL)
return;
TrackerSettings settings;
if (settings.ShowVolumeSpaceBar() != fSpaceBarShow) {
settings.SetShowVolumeSpaceBar(fSpaceBarShow);
send_bool_notices(kShowVolumeSpaceBar, "ShowVolumeSpaceBar",
fSpaceBarShow);
}
if (settings.UsedSpaceColor() != fUsedSpaceColor
|| settings.FreeSpaceColor() != fFreeSpaceColor
|| settings.WarningSpaceColor() != fWarningSpaceColor) {
settings.SetUsedSpaceColor(fUsedSpaceColor);
settings.SetFreeSpaceColor(fFreeSpaceColor);
settings.SetWarningSpaceColor(fWarningSpaceColor);
tracker->SendNotices(kSpaceBarColorChanged);
}
ShowCurrentSettings();
}
void
SpaceBarSettingsView::ShowCurrentSettings()
{
TrackerSettings settings;
fSpaceBarShowCheckBox->SetValue(settings.ShowVolumeSpaceBar());
switch (fCurrentColor) {
case 0:
fColorControl->SetValue(settings.UsedSpaceColor());
break;
case 1:
fColorControl->SetValue(settings.FreeSpaceColor());
break;
case 2:
fColorControl->SetValue(settings.WarningSpaceColor());
break;
}
}
void
SpaceBarSettingsView::RecordRevertSettings()
{
TrackerSettings settings;
fSpaceBarShow = settings.ShowVolumeSpaceBar();
fUsedSpaceColor = settings.UsedSpaceColor();
fFreeSpaceColor = settings.FreeSpaceColor();
fWarningSpaceColor = settings.WarningSpaceColor();
}
bool
SpaceBarSettingsView::IsRevertable() const
{
TrackerSettings settings;
return fSpaceBarShow != settings.ShowVolumeSpaceBar()
|| fUsedSpaceColor != settings.UsedSpaceColor()
|| fFreeSpaceColor != settings.FreeSpaceColor()
|| fWarningSpaceColor != settings.WarningSpaceColor();
}
