/*! Reflect active mode in chosen settings */
void
ScreenWindow::_UpdateActiveMode()
{
// Usually, this function gets called after a mode
// has been set manually; still, as the graphics driver
// is free to fiddle with mode passed, we better ask
// what kind of mode we actually got
fScreenMode.Get(fActive);
fSelected = fActive;
_UpdateMonitor();
_UpdateControls();
}
void
ScreenWindow::_UpdateActiveMode(int32 workspace)
{
// Usually, this function gets called after a mode
// has been set manually; still, as the graphics driver
// is free to fiddle with mode passed, we better ask
// what kind of mode we actually got
if (fScreenMode.Get(fActive, workspace) == B_OK) {
fSelected = fActive;
_UpdateMonitor();
_BuildSupportedColorSpaces();
_UpdateControls();
}
}
void
InstallerWindow::_ScanPartitions()
{
_SetStatusMessage(TR("Scanning for disks" B_UTF8_ELLIPSIS));
BMenuItem *item;
while ((item = fSrcMenu->RemoveItem((int32)0)))
delete item;
while ((item = fDestMenu->RemoveItem((int32)0)))
delete item;
fWorkerThread->ScanDisksPartitions(fSrcMenu, fDestMenu);
if (fSrcMenu->ItemAt(0)) {
_PublishPackages();
}
_UpdateControls();
}
// MessageReceived
void
ObjectWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case MSG_SET_OBJECT_TYPE: {
int32 type;
if (message->FindInt32("type", &type) >= B_OK) {
fObjectView->SetObjectType(type);
fFillCB->SetEnabled(type != OBJECT_LINE);
if (!fFillCB->IsEnabled())
fPenSizeS->SetEnabled(true);
else
fPenSizeS->SetEnabled(fFillCB->Value() == B_CONTROL_OFF);
}
break;
}
case MSG_SET_FILL_OR_STROKE: {
int32 value;
if (message->FindInt32("be:value", &value) >= B_OK) {
fObjectView->SetStateFill(value);
fPenSizeS->SetEnabled(value == B_CONTROL_OFF);
}
break;
}
case MSG_SET_COLOR:
fObjectView->SetStateColor(_GetColor());
_UpdateColorControls();
break;
case MSG_OBJECT_ADDED: {
State* object;
if (message->FindPointer("object", (void**)&object) >= B_OK) {
fObjectLV->AddItem(new ObjectItem("Object", object));
}
// fall through
}
case MSG_OBJECT_COUNT_CHANGED:
fClearB->SetEnabled(fObjectView->CountObjects() > 0);
break;
case MSG_OBJECT_SELECTED:
if (ObjectItem* item = (ObjectItem*)fObjectLV->ItemAt(fObjectLV->CurrentSelection(0))) {
fObjectView->SetState(item->Object());
fObjectView->SetStateColor(item->Object()->Color());
_UpdateControls();
} else
fObjectView->SetState(NULL);
break;
case MSG_REMOVE_OBJECT:
while (ObjectItem* item = (ObjectItem*)fObjectLV->ItemAt(fObjectLV->CurrentSelection(0))) {
fObjectView->RemoveObject(item->Object());
fObjectLV->RemoveItem(item);
delete item;
}
break;
case MSG_NEW_OBJECT:
fObjectView->SetState(NULL);
break;
case MSG_CLEAR: {
BAlert *alert = new BAlert("Playground",
"Do you really want to clear all drawing objects?",
"No", "Yes");
if (alert->Go() == 1) {
fObjectView->MakeEmpty();
fObjectLV->MakeEmpty();
}
break;
}
case MSG_SET_PEN_SIZE:
fObjectView->SetStatePenSize((float)fPenSizeS->Value());
break;
case MSG_SET_DRAWING_MODE: {
drawing_mode mode;
if (message->FindInt32("mode", (int32*)&mode) >= B_OK) {
fObjectView->SetStateDrawingMode(mode);
}
break;
}
default:
BWindow::MessageReceived(message);
}
}
// constructor
ObjectWindow::ObjectWindow(BRect frame, const char* name)
: BWindow(frame, name, B_DOCUMENT_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE)
{
BRect b(Bounds());
b.bottom = b.top + 8;
BMenuBar* menuBar = new BMenuBar(b, "menu bar");
AddChild(menuBar);
BMenu* menu = new BMenu("File");
menuBar->AddItem(menu);
menu->AddItem(new BMenu("Submenu"));
BMenuItem* menuItem = new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED),
'Q');
menu->AddItem(menuItem);
b = Bounds();
b.top = menuBar->Bounds().bottom + 1;
b.right = ceilf((b.left + b.right) / 2.0);
BBox* bg = new BBox(b, "bg box", B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW,
B_PLAIN_BORDER);
AddChild(bg);
bg->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
// object view occupies the right side of the window
b.left = b.right + 1.0;
b.right = Bounds().right - B_V_SCROLL_BAR_WIDTH;
b.bottom -= B_H_SCROLL_BAR_HEIGHT;
fObjectView = new ObjectView(b, "object view", B_FOLLOW_ALL,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE);
// wrap a scroll view around the object view
BScrollView* scrollView = new BScrollView("object scroller", fObjectView,
B_FOLLOW_ALL, 0, true, true, B_NO_BORDER);
if (BScrollBar* scrollBar = fObjectView->ScrollBar(B_VERTICAL)) {
scrollBar->SetRange(0.0, fObjectView->Bounds().Height());
scrollBar->SetProportion(0.5);
}
if (BScrollBar* scrollBar = fObjectView->ScrollBar(B_HORIZONTAL)) {
scrollBar->SetRange(0.0, fObjectView->Bounds().Width());
scrollBar->SetProportion(0.5);
}
AddChild(scrollView);
b = bg->Bounds();
// controls occupy the left side of the window
b.InsetBy(5.0, 5.0);
BBox* controlGroup = new BBox(b, "controls box",
B_FOLLOW_LEFT | B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW, B_FANCY_BORDER);
controlGroup->SetLabel("Controls");
bg->AddChild(controlGroup);
b = controlGroup->Bounds();
b.top += controlGroup->InnerFrame().top;
b.bottom = b.top + 25.0;
b.InsetBy(10.0, 10.0);
b.right = b.left + b.Width() / 2.0 - 5.0;
// new button
fNewB = new BButton(b, "new button", "New Object",
new BMessage(MSG_NEW_OBJECT));
controlGroup->AddChild(fNewB);
SetDefaultButton(fNewB);
// clear button
b.OffsetBy(0, fNewB->Bounds().Height() + 5.0);
fClearB = new BButton(b, "clear button", "Clear", new BMessage(MSG_CLEAR));
controlGroup->AddChild(fClearB);
// object type radio buttons
BMessage* message;
BRadioButton* radioButton;
b.OffsetBy(0, fClearB->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_LINE);
radioButton = new BRadioButton(b, "radio 1", "Line", message);
controlGroup->AddChild(radioButton);
radioButton->SetValue(B_CONTROL_ON);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_RECT);
radioButton = new BRadioButton(b, "radio 2", "Rect", message);
controlGroup->AddChild(radioButton);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_ROUND_RECT);
radioButton = new BRadioButton(b, "radio 3", "Round Rect", message);
controlGroup->AddChild(radioButton);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_ELLIPSE);
radioButton = new BRadioButton(b, "radio 4", "Ellipse", message);
controlGroup->AddChild(radioButton);
// drawing mode
BPopUpMenu* popupMenu = new BPopUpMenu("<pick>");
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_COPY);
popupMenu->AddItem(new BMenuItem("Copy", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_OVER);
popupMenu->AddItem(new BMenuItem("Over", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_INVERT);
popupMenu->AddItem(new BMenuItem("Invert", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_BLEND);
popupMenu->AddItem(new BMenuItem("Blend", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_SELECT);
popupMenu->AddItem(new BMenuItem("Select", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ERASE);
popupMenu->AddItem(new BMenuItem("Erase", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ADD);
popupMenu->AddItem(new BMenuItem("Add", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_SUBTRACT);
popupMenu->AddItem(new BMenuItem("Subtract", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_MIN);
popupMenu->AddItem(new BMenuItem("Min", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_MAX);
popupMenu->AddItem(new BMenuItem("Max", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ALPHA);
BMenuItem* item = new BMenuItem("Alpha", message);
item->SetMarked(true);
popupMenu->AddItem(item);
b.OffsetBy(0, radioButton->Bounds().Height() + 10.0);
fDrawingModeMF = new BMenuField(b, "drawing mode field", "Mode:",
popupMenu);
controlGroup->AddChild(fDrawingModeMF);
fDrawingModeMF->SetDivider(fDrawingModeMF->StringWidth(
fDrawingModeMF->Label()) + 10.0);
// color control
b.OffsetBy(0, fDrawingModeMF->Bounds().Height() + 10.0);
fColorControl = new BColorControl(b.LeftTop(), B_CELLS_16x16, 8,
"color control", new BMessage(MSG_SET_COLOR));
controlGroup->AddChild(fColorControl);
// alpha text control
b.OffsetBy(0, fColorControl-> Bounds().Height() + 5.0);
fAlphaTC = new BTextControl(b, "alpha text control", "Alpha:", "",
new BMessage(MSG_SET_COLOR));
controlGroup->AddChild(fAlphaTC);
// divide text controls the same
float mWidth = fDrawingModeMF->StringWidth(fDrawingModeMF->Label());
float aWidth = fAlphaTC->StringWidth(fAlphaTC->Label());
float width = max_c(mWidth, aWidth) + 20.0;
fDrawingModeMF->SetDivider(width);
fAlphaTC->SetDivider(width);
// fill check box
b.OffsetBy(0, fAlphaTC->Bounds().Height() + 5.0);
fFillCB = new BCheckBox(b, "fill check box", "Fill",
new BMessage(MSG_SET_FILL_OR_STROKE));
controlGroup->AddChild(fFillCB);
// pen size text control
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
b.bottom = b.top + 10.0;//35;
fPenSizeS = new BSlider(b, "width slider", "Width:", NULL, 1, 100,
B_TRIANGLE_THUMB);
fPenSizeS->SetLimitLabels("1", "100");
fPenSizeS->SetModificationMessage(new BMessage(MSG_SET_PEN_SIZE));
fPenSizeS->SetHashMarks(B_HASH_MARKS_BOTTOM);
fPenSizeS->SetHashMarkCount(10);
controlGroup->AddChild(fPenSizeS);
// list view with objects
b = controlGroup->Bounds();
b.top += controlGroup->InnerFrame().top;
b.InsetBy(10.0, 10.0);
b.left = b.left + b.Width() / 2.0 + 6.0;
b.right -= B_V_SCROLL_BAR_WIDTH;
b.bottom = fDrawingModeMF->Frame().top - 10.0;
fObjectLV = new ObjectListView(b, "object list", B_SINGLE_SELECTION_LIST);
fObjectLV->SetSelectionMessage(new BMessage(MSG_OBJECT_SELECTED));
// wrap a scroll view around the list view
scrollView = new BScrollView("list scroller", fObjectLV,
B_FOLLOW_NONE, 0, false, true, B_FANCY_BORDER);
controlGroup->AddChild(scrollView);
// enforce some size limits
float minWidth = controlGroup->Frame().Width() + 30.0;
float minHeight = fPenSizeS->Frame().bottom
+ menuBar->Bounds().Height() + 15.0;
float maxWidth = minWidth * 4.0;
float maxHeight = minHeight + 100;
SetSizeLimits(minWidth, maxWidth, minHeight, maxHeight);
ResizeTo(max_c(frame.Width(), minWidth), max_c(frame.Height(), minHeight));
_UpdateControls();
}
void
ScreenWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case WORKSPACE_CHECK_MSG:
_CheckApplyEnabled();
break;
case kMsgWorkspaceLayoutChanged:
{
int32 deltaX = 0;
int32 deltaY = 0;
message->FindInt32("delta_x", &deltaX);
message->FindInt32("delta_y", &deltaY);
if (deltaX == 0 && deltaY == 0)
break;
uint32 newColumns;
uint32 newRows;
BPrivate::get_workspaces_layout(&newColumns, &newRows);
newColumns += deltaX;
newRows += deltaY;
BPrivate::set_workspaces_layout(newColumns, newRows);
_UpdateWorkspaceButtons();
_CheckApplyEnabled();
break;
}
case kMsgWorkspaceColumnsChanged:
{
uint32 newColumns = strtoul(fColumnsControl->Text(), NULL, 10);
uint32 rows;
BPrivate::get_workspaces_layout(NULL, &rows);
BPrivate::set_workspaces_layout(newColumns, rows);
_UpdateWorkspaceButtons();
_CheckApplyEnabled();
break;
}
case kMsgWorkspaceRowsChanged:
{
uint32 newRows = strtoul(fRowsControl->Text(), NULL, 10);
uint32 columns;
BPrivate::get_workspaces_layout(&columns, NULL);
BPrivate::set_workspaces_layout(columns, newRows);
_UpdateWorkspaceButtons();
_CheckApplyEnabled();
break;
}
case POP_RESOLUTION_MSG:
{
message->FindInt32("width", &fSelected.width);
message->FindInt32("height", &fSelected.height);
_CheckColorMenu();
_CheckRefreshMenu();
_UpdateMonitorView();
_UpdateRefreshControl();
_CheckApplyEnabled();
break;
}
case POP_COLORS_MSG:
{
int32 space;
if (message->FindInt32("space", &space) != B_OK)
break;
int32 index;
if (message->FindInt32("index", &index) == B_OK
&& fColorsMenu->ItemAt(index) != NULL)
fUserSelectedColorSpace = fColorsMenu->ItemAt(index);
fSelected.space = (color_space)space;
_UpdateColorLabel();
_CheckApplyEnabled();
break;
}
case POP_REFRESH_MSG:
{
message->FindFloat("refresh", &fSelected.refresh);
fOtherRefresh->SetLabel(B_TRANSLATE("Other" B_UTF8_ELLIPSIS));
// revert "Other…" label - it might have a refresh rate prefix
_CheckApplyEnabled();
break;
}
case POP_OTHER_REFRESH_MSG:
{
// make sure menu shows something useful
_UpdateRefreshControl();
float min = 0, max = 999;
fScreenMode.GetRefreshLimits(fSelected, min, max);
if (min < gMinRefresh)
min = gMinRefresh;
if (max > gMaxRefresh)
max = gMaxRefresh;
monitor_info info;
if (fScreenMode.GetMonitorInfo(info) == B_OK) {
min = max_c(info.min_vertical_frequency, min);
max = min_c(info.max_vertical_frequency, max);
}
RefreshWindow *fRefreshWindow = new RefreshWindow(
fRefreshField->ConvertToScreen(B_ORIGIN), fSelected.refresh,
min, max);
fRefreshWindow->Show();
break;
}
case SET_CUSTOM_REFRESH_MSG:
{
// user pressed "done" in "Other…" refresh dialog;
// select the refresh rate chosen
message->FindFloat("refresh", &fSelected.refresh);
_UpdateRefreshControl();
_CheckApplyEnabled();
break;
}
case POP_COMBINE_DISPLAYS_MSG:
{
// new combine mode has bee chosen
int32 mode;
if (message->FindInt32("mode", &mode) == B_OK)
fSelected.combine = (combine_mode)mode;
_CheckResolutionMenu();
_CheckApplyEnabled();
break;
}
case POP_SWAP_DISPLAYS_MSG:
message->FindBool("swap", &fSelected.swap_displays);
_CheckApplyEnabled();
break;
case POP_USE_LAPTOP_PANEL_MSG:
message->FindBool("use", &fSelected.use_laptop_panel);
_CheckApplyEnabled();
break;
case POP_TV_STANDARD_MSG:
message->FindInt32("tv_standard", (int32 *)&fSelected.tv_standard);
_CheckApplyEnabled();
break;
case BUTTON_LAUNCH_BACKGROUNDS_MSG:
if (be_roster->Launch(kBackgroundsSignature) == B_ALREADY_RUNNING) {
app_info info;
be_roster->GetAppInfo(kBackgroundsSignature, &info);
be_roster->ActivateApp(info.team);
}
break;
case BUTTON_DEFAULTS_MSG:
{
// TODO: get preferred settings of screen
fSelected.width = 640;
fSelected.height = 480;
fSelected.space = B_CMAP8;
fSelected.refresh = 60.0;
fSelected.combine = kCombineDisable;
fSelected.swap_displays = false;
fSelected.use_laptop_panel = false;
fSelected.tv_standard = 0;
// TODO: workspace defaults
_UpdateControls();
break;
}
case BUTTON_UNDO_MSG:
fUndoScreenMode.Revert();
_UpdateActiveMode();
break;
case BUTTON_REVERT_MSG:
{
fModified = false;
fBootWorkspaceApplied = false;
// ScreenMode::Revert() assumes that we first set the correct
// number of workspaces
BPrivate::set_workspaces_layout(fOriginalWorkspacesColumns,
fOriginalWorkspacesRows);
_UpdateWorkspaceButtons();
fScreenMode.Revert();
_UpdateActiveMode();
break;
}
case BUTTON_APPLY_MSG:
_Apply();
break;
case MAKE_INITIAL_MSG:
// user pressed "keep" in confirmation dialog
fModified = true;
_UpdateActiveMode();
break;
default:
BWindow::MessageReceived(message);
break;
}
}
ScreenWindow::ScreenWindow(ScreenSettings* settings)
:
BWindow(settings->WindowFrame(), B_TRANSLATE_SYSTEM_NAME("Screen"),
B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE
| B_AUTO_UPDATE_SIZE_LIMITS, B_ALL_WORKSPACES),
fIsVesa(false),
fBootWorkspaceApplied(false),
fOtherRefresh(NULL),
fScreenMode(this),
fUndoScreenMode(this),
fModified(false)
{
BScreen screen(this);
accelerant_device_info info;
if (screen.GetDeviceInfo(&info) == B_OK
&& !strcasecmp(info.chipset, "VESA"))
fIsVesa = true;
_UpdateOriginal();
_BuildSupportedColorSpaces();
fActive = fSelected = fOriginal;
fSettings = settings;
// we need the "Current Workspace" first to get its height
BPopUpMenu *popUpMenu = new BPopUpMenu(B_TRANSLATE("Current workspace"),
true, true);
fAllWorkspacesItem = new BMenuItem(B_TRANSLATE("All workspaces"),
new BMessage(WORKSPACE_CHECK_MSG));
popUpMenu->AddItem(fAllWorkspacesItem);
BMenuItem *item = new BMenuItem(B_TRANSLATE("Current workspace"),
new BMessage(WORKSPACE_CHECK_MSG));
popUpMenu->AddItem(item);
fAllWorkspacesItem->SetMarked(true);
BMenuField* workspaceMenuField = new BMenuField("WorkspaceMenu", NULL,
popUpMenu);
workspaceMenuField->ResizeToPreferred();
// box on the left with workspace count and monitor view
BBox* screenBox = new BBox("screen box");
BGroupLayout* layout = new BGroupLayout(B_VERTICAL, 5.0);
layout->SetInsets(10, 10, 10, 10);
screenBox->SetLayout(layout);
fMonitorInfo = new BStringView("monitor info", "");
screenBox->AddChild(fMonitorInfo);
fMonitorView = new MonitorView(BRect(0.0, 0.0, 80.0, 80.0),
"monitor", screen.Frame().IntegerWidth() + 1,
screen.Frame().IntegerHeight() + 1);
screenBox->AddChild(fMonitorView);
fColumnsControl = new BTextControl(B_TRANSLATE("Columns:"), "0",
new BMessage(kMsgWorkspaceColumnsChanged));
fRowsControl = new BTextControl(B_TRANSLATE("Rows:"), "0",
new BMessage(kMsgWorkspaceRowsChanged));
screenBox->AddChild(BLayoutBuilder::Grid<>(5.0, 5.0)
.Add(new BStringView("", B_TRANSLATE("Workspaces")), 0, 0, 3)
.AddTextControl(fColumnsControl, 0, 1, B_ALIGN_RIGHT)
.AddGroup(B_HORIZONTAL, 0, 2, 1)
.Add(_CreateColumnRowButton(true, false))
.Add(_CreateColumnRowButton(true, true))
.End()
.AddTextControl(fRowsControl, 0, 2, B_ALIGN_RIGHT)
.AddGroup(B_HORIZONTAL, 0, 2, 2)
.Add(_CreateColumnRowButton(false, false))
.Add(_CreateColumnRowButton(false, true))
.End()
.View());
fBackgroundsButton = new BButton("BackgroundsButton",
B_TRANSLATE("Set background" B_UTF8_ELLIPSIS),
new BMessage(BUTTON_LAUNCH_BACKGROUNDS_MSG));
fBackgroundsButton->SetFontSize(be_plain_font->Size() * 0.9);
screenBox->AddChild(fBackgroundsButton);
// box on the right with screen resolution, etc.
BBox* controlsBox = new BBox("controls box");
controlsBox->SetLabel(workspaceMenuField);
BGroupView* outerControlsView = new BGroupView(B_VERTICAL, 10.0);
outerControlsView->GroupLayout()->SetInsets(10, 10, 10, 10);
controlsBox->AddChild(outerControlsView);
fResolutionMenu = new BPopUpMenu("resolution", true, true);
uint16 maxWidth = 0;
uint16 maxHeight = 0;
uint16 previousWidth = 0;
uint16 previousHeight = 0;
for (int32 i = 0; i < fScreenMode.CountModes(); i++) {
screen_mode mode = fScreenMode.ModeAt(i);
if (mode.width == previousWidth && mode.height == previousHeight)
continue;
previousWidth = mode.width;
previousHeight = mode.height;
if (maxWidth < mode.width)
maxWidth = mode.width;
if (maxHeight < mode.height)
maxHeight = mode.height;
BMessage* message = new BMessage(POP_RESOLUTION_MSG);
message->AddInt32("width", mode.width);
message->AddInt32("height", mode.height);
BString name;
name << mode.width << " x " << mode.height;
fResolutionMenu->AddItem(new BMenuItem(name.String(), message));
}
fMonitorView->SetMaxResolution(maxWidth, maxHeight);
fResolutionField = new BMenuField("ResolutionMenu",
B_TRANSLATE("Resolution:"), fResolutionMenu);
fColorsMenu = new BPopUpMenu("colors", true, false);
for (int32 i = 0; i < kColorSpaceCount; i++) {
if ((fSupportedColorSpaces & (1 << i)) == 0)
continue;
BMessage* message = new BMessage(POP_COLORS_MSG);
message->AddInt32("bits_per_pixel", kColorSpaces[i].bits_per_pixel);
message->AddInt32("space", kColorSpaces[i].space);
BMenuItem* item = new BMenuItem(kColorSpaces[i].label, message);
if (kColorSpaces[i].space == screen.ColorSpace())
fUserSelectedColorSpace = item;
fColorsMenu->AddItem(item);
}
fColorsField = new BMenuField("ColorsMenu", B_TRANSLATE("Colors:"),
fColorsMenu);
fRefreshMenu = new BPopUpMenu("refresh rate", true, true);
float min, max;
if (fScreenMode.GetRefreshLimits(fActive, min, max) != B_OK) {
// if we couldn't obtain the refresh limits, reset to the default
// range. Constraints from detected monitors will fine-tune this
// later.
min = kRefreshRates[0];
max = kRefreshRates[kRefreshRateCount - 1];
}
if (min == max) {
// This is a special case for drivers that only support a single
// frequency, like the VESA driver
BString name;
refresh_rate_to_string(min, name);
BMessage *message = new BMessage(POP_REFRESH_MSG);
message->AddFloat("refresh", min);
BMenuItem *item = new BMenuItem(name.String(), message);
fRefreshMenu->AddItem(item);
item->SetEnabled(false);
} else {
monitor_info info;
if (fScreenMode.GetMonitorInfo(info) == B_OK) {
min = max_c(info.min_vertical_frequency, min);
max = min_c(info.max_vertical_frequency, max);
}
for (int32 i = 0; i < kRefreshRateCount; ++i) {
if (kRefreshRates[i] < min || kRefreshRates[i] > max)
continue;
BString name;
name << kRefreshRates[i] << " " << B_TRANSLATE("Hz");
BMessage *message = new BMessage(POP_REFRESH_MSG);
message->AddFloat("refresh", kRefreshRates[i]);
fRefreshMenu->AddItem(new BMenuItem(name.String(), message));
}
fOtherRefresh = new BMenuItem(B_TRANSLATE("Other" B_UTF8_ELLIPSIS),
new BMessage(POP_OTHER_REFRESH_MSG));
fRefreshMenu->AddItem(fOtherRefresh);
}
fRefreshField = new BMenuField("RefreshMenu", B_TRANSLATE("Refresh rate:"),
fRefreshMenu);
if (_IsVesa())
fRefreshField->Hide();
// enlarged area for multi-monitor settings
{
bool dummy;
uint32 dummy32;
bool multiMonSupport;
bool useLaptopPanelSupport;
bool tvStandardSupport;
multiMonSupport = TestMultiMonSupport(&screen) == B_OK;
useLaptopPanelSupport = GetUseLaptopPanel(&screen, &dummy) == B_OK;
tvStandardSupport = GetTVStandard(&screen, &dummy32) == B_OK;
// even if there is no support, we still create all controls
// to make sure we don't access NULL pointers later on
fCombineMenu = new BPopUpMenu("CombineDisplays",
true, true);
for (int32 i = 0; i < kCombineModeCount; i++) {
BMessage *message = new BMessage(POP_COMBINE_DISPLAYS_MSG);
message->AddInt32("mode", kCombineModes[i].mode);
fCombineMenu->AddItem(new BMenuItem(kCombineModes[i].name,
message));
}
fCombineField = new BMenuField("CombineMenu",
B_TRANSLATE("Combine displays:"), fCombineMenu);
if (!multiMonSupport)
fCombineField->Hide();
fSwapDisplaysMenu = new BPopUpMenu("SwapDisplays",
true, true);
// !order is important - we rely that boolean value == idx
BMessage *message = new BMessage(POP_SWAP_DISPLAYS_MSG);
message->AddBool("swap", false);
fSwapDisplaysMenu->AddItem(new BMenuItem(B_TRANSLATE("no"), message));
message = new BMessage(POP_SWAP_DISPLAYS_MSG);
message->AddBool("swap", true);
fSwapDisplaysMenu->AddItem(new BMenuItem(B_TRANSLATE("yes"), message));
fSwapDisplaysField = new BMenuField("SwapMenu",
B_TRANSLATE("Swap displays:"), fSwapDisplaysMenu);
if (!multiMonSupport)
fSwapDisplaysField->Hide();
fUseLaptopPanelMenu = new BPopUpMenu("UseLaptopPanel",
true, true);
// !order is important - we rely that boolean value == idx
message = new BMessage(POP_USE_LAPTOP_PANEL_MSG);
message->AddBool("use", false);
fUseLaptopPanelMenu->AddItem(new BMenuItem(B_TRANSLATE("if needed"),
message));
message = new BMessage(POP_USE_LAPTOP_PANEL_MSG);
message->AddBool("use", true);
fUseLaptopPanelMenu->AddItem(new BMenuItem(B_TRANSLATE("always"),
message));
fUseLaptopPanelField = new BMenuField("UseLaptopPanel",
B_TRANSLATE("Use laptop panel:"), fUseLaptopPanelMenu);
if (!useLaptopPanelSupport)
fUseLaptopPanelField->Hide();
fTVStandardMenu = new BPopUpMenu("TVStandard", true, true);
// arbitrary limit
uint32 i;
for (i = 0; i < 100; ++i) {
uint32 mode;
if (GetNthSupportedTVStandard(&screen, i, &mode) != B_OK)
break;
BString name = tv_standard_to_string(mode);
message = new BMessage(POP_TV_STANDARD_MSG);
message->AddInt32("tv_standard", mode);
fTVStandardMenu->AddItem(new BMenuItem(name.String(), message));
}
fTVStandardField = new BMenuField("tv standard",
B_TRANSLATE("Video format:"), fTVStandardMenu);
fTVStandardField->SetAlignment(B_ALIGN_RIGHT);
if (!tvStandardSupport || i == 0)
fTVStandardField->Hide();
}
BLayoutBuilder::Group<>(outerControlsView)
.AddGrid(5.0, 5.0)
.AddMenuField(fResolutionField, 0, 0, B_ALIGN_RIGHT)
.AddMenuField(fColorsField, 0, 1, B_ALIGN_RIGHT)
.AddMenuField(fRefreshField, 0, 2, B_ALIGN_RIGHT)
.AddMenuField(fCombineField, 0, 3, B_ALIGN_RIGHT)
.AddMenuField(fSwapDisplaysField, 0, 4, B_ALIGN_RIGHT)
.AddMenuField(fUseLaptopPanelField, 0, 5, B_ALIGN_RIGHT)
.AddMenuField(fTVStandardField, 0, 6, B_ALIGN_RIGHT)
.End();
// TODO: we don't support getting the screen's preferred settings
/* fDefaultsButton = new BButton(buttonRect, "DefaultsButton", "Defaults",
new BMessage(BUTTON_DEFAULTS_MSG));*/
fApplyButton = new BButton("ApplyButton", B_TRANSLATE("Apply"),
new BMessage(BUTTON_APPLY_MSG));
fApplyButton->SetEnabled(false);
BLayoutBuilder::Group<>(outerControlsView)
.AddGlue()
.AddGroup(B_HORIZONTAL)
.AddGlue()
.Add(fApplyButton);
fRevertButton = new BButton("RevertButton", B_TRANSLATE("Revert"),
new BMessage(BUTTON_REVERT_MSG));
fRevertButton->SetEnabled(false);
BLayoutBuilder::Group<>(this, B_VERTICAL, 10.0)
.SetInsets(10, 10, 10, 10)
.AddGroup(B_HORIZONTAL, 10.0)
.AddGroup(B_VERTICAL)
.AddStrut(floor(controlsBox->TopBorderOffset() / 16) - 1)
.Add(screenBox)
.End()
.Add(controlsBox)
.End()
.AddGroup(B_HORIZONTAL, 10.0)
.Add(fRevertButton)
.AddGlue();
_UpdateControls();
_UpdateMonitor();
}
void
InstallerWindow::MessageReceived(BMessage *msg)
{
switch (msg->what) {
case MSG_RESET:
{
_SetCopyEngineCancelSemaphore(-1);
status_t error;
if (msg->FindInt32("error", &error) == B_OK) {
char errorMessage[2048];
snprintf(errorMessage, sizeof(errorMessage), TR("An error was "
"encountered and the installation was not completed:\n\n"
"Error: %s"), strerror(error));
(new BAlert("error", errorMessage, TR("OK")))->Go();
}
_DisableInterface(false);
fProgressLayoutItem->SetVisible(false);
fPkgSwitchLayoutItem->SetVisible(true);
_ShowOptionalPackages();
_UpdateControls();
break;
}
case START_SCAN:
_ScanPartitions();
break;
case BEGIN_MESSAGE:
switch (fInstallStatus) {
case kReadyForInstall:
{
_SetCopyEngineCancelSemaphore(create_sem(1,
"copy engine cancel"));
BList* list = new BList();
int32 size = 0;
fPackagesView->GetPackagesToInstall(list, &size);
fWorkerThread->SetLock(fCopyEngineCancelSemaphore);
fWorkerThread->SetPackagesList(list);
fWorkerThread->SetSpaceRequired(size);
fInstallStatus = kInstalling;
fWorkerThread->StartInstall();
fBeginButton->SetLabel(TR("Stop"));
_DisableInterface(true);
fProgressBar->SetTo(0.0, NULL, NULL);
fPkgSwitchLayoutItem->SetVisible(false);
fPackagesLayoutItem->SetVisible(false);
fSizeViewLayoutItem->SetVisible(false);
fProgressLayoutItem->SetVisible(true);
break;
}
case kInstalling:
{
_QuitCopyEngine(true);
break;
}
case kFinished:
PostMessage(B_QUIT_REQUESTED);
break;
case kCancelled:
break;
}
break;
case SHOW_BOTTOM_MESSAGE:
_ShowOptionalPackages();
break;
case SOURCE_PARTITION:
_PublishPackages();
_UpdateControls();
break;
case TARGET_PARTITION:
_UpdateControls();
break;
case SETUP_MESSAGE:
_LaunchDriveSetup();
break;
case PACKAGE_CHECKBOX:
{
char buffer[15];
fPackagesView->GetTotalSizeAsString(buffer);
char string[255];
sprintf(string, TR("Additional disk space required: %s"), buffer);
fSizeView->SetText(string);
break;
}
case ENCOURAGE_DRIVESETUP:
{
(new BAlert("use drive setup", TR("No partitions have been found "
"that are suitable for installation. Please set up partitions "
"and initialize at least one partition with the Be File "
"System."), TR("OK")))->Go();
}
case MSG_STATUS_MESSAGE:
{
// TODO: Was this supposed to prevent status messages still arriving
// after the copy engine was shut down?
// if (fInstallStatus != kInstalling)
// break;
float progress;
if (msg->FindFloat("progress", &progress) == B_OK) {
const char* currentItem;
if (msg->FindString("item", ¤tItem) != B_OK) {
currentItem = TR_CMT("???",
"Unknown currently copied item");
}
BString trailingLabel;
int32 currentCount;
int32 maximumCount;
if (msg->FindInt32("current", ¤tCount) == B_OK
&& msg->FindInt32("maximum", &maximumCount) == B_OK) {
char buffer[64];
snprintf(buffer, sizeof(buffer), TR_CMT("%1ld of %2ld",
"number of files copied"), currentCount, maximumCount);
trailingLabel << buffer;
} else {
trailingLabel << TR_CMT("?? of ??", "Unknown progress");
}
fProgressBar->SetTo(progress, currentItem,
trailingLabel.String());
} else {
const char *status;
if (msg->FindString("status", &status) == B_OK) {
fLastStatus = fStatusView->Text();
_SetStatusMessage(status);
} else
_SetStatusMessage(fLastStatus.String());
}
break;
}
case MSG_INSTALL_FINISHED:
{
_SetCopyEngineCancelSemaphore(-1);
fBeginButton->SetLabel(TR("Quit"));
PartitionMenuItem* dstItem
= (PartitionMenuItem*)fDestMenu->FindMarked();
char status[1024];
if (be_roster->IsRunning(kDeskbarSignature)) {
snprintf(status, sizeof(status), TR("Installation completed. "
"Boot sector has been written to '%s'. Press Quit to "
"leave the Installer or choose a new target volume to "
"perform another installation."),
dstItem ? dstItem->Name() : TR_CMT("???",
"Unknown partition name"));
} else {
snprintf(status, sizeof(status), TR("Installation completed. "
"Boot sector has been written to '%s'. Press Quit to "
"restart the computer or choose a new target volume "
"to perform another installation."),
dstItem ? dstItem->Name() : TR_CMT("???",
"Unknown partition name"));
}
_SetStatusMessage(status);
fInstallStatus = kFinished;
_DisableInterface(false);
fProgressLayoutItem->SetVisible(false);
fPkgSwitchLayoutItem->SetVisible(true);
_ShowOptionalPackages();
break;
}
case B_SOME_APP_LAUNCHED:
case B_SOME_APP_QUIT:
{
const char *signature;
if (msg->FindString("be:signature", &signature) == B_OK
&& strcasecmp(signature, DRIVESETUP_SIG) == 0) {
fDriveSetupLaunched = msg->what == B_SOME_APP_LAUNCHED;
fBeginButton->SetEnabled(!fDriveSetupLaunched);
_DisableInterface(fDriveSetupLaunched);
if (fDriveSetupLaunched)
_SetStatusMessage(TR("Running DriveSetup" B_UTF8_ELLIPSIS
"\n\nClose DriveSetup to continue with the "
"installation."));
else
_ScanPartitions();
}
break;
}
case MSG_WRITE_BOOT_SECTOR:
fWorkerThread->WriteBootSector(fDestMenu);
break;
default:
BWindow::MessageReceived(msg);
break;
}
}
