SettingsView::SettingsView(MouseSettings& settings)
: BBox("main_view"),
fSettings(settings)
{
// Add the "Mouse Type" pop up menu
fTypeMenu = new BPopUpMenu("unknown");
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("1-Button"),
new BMessage(kMsgMouseType)));
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("2-Button"),
new BMessage(kMsgMouseType)));
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("3-Button"),
new BMessage(kMsgMouseType)));
BMenuField* typeField = new BMenuField(B_TRANSLATE("Mouse type:"),
fTypeMenu);
typeField->SetAlignment(B_ALIGN_RIGHT);
// Create the "Double-click speed slider...
fClickSpeedSlider = new BSlider("double_click_speed",
B_TRANSLATE("Double-click speed"), new BMessage(kMsgDoubleClickSpeed),
0, 1000, B_HORIZONTAL);
fClickSpeedSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fClickSpeedSlider->SetHashMarkCount(5);
fClickSpeedSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
// Create the "Mouse Speed" slider...
fMouseSpeedSlider = new BSlider("mouse_speed", B_TRANSLATE("Mouse speed"),
new BMessage(kMsgMouseSpeed), 0, 1000, B_HORIZONTAL);
fMouseSpeedSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fMouseSpeedSlider->SetHashMarkCount(7);
fMouseSpeedSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
// Create the "Mouse Acceleration" slider...
fAccelerationSlider = new BSlider("mouse_acceleration",
B_TRANSLATE("Mouse acceleration"),
new BMessage(kMsgAccelerationFactor), 0, 1000, B_HORIZONTAL);
fAccelerationSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fAccelerationSlider->SetHashMarkCount(5);
fAccelerationSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
// Mouse image...
fMouseView = new MouseView(fSettings);
// Create the "Double-click test area" text box...
BTextControl* doubleClickTextControl = new BTextControl(NULL,
B_TRANSLATE("Double-click test area"), NULL);
doubleClickTextControl->SetAlignment(B_ALIGN_LEFT, B_ALIGN_CENTER);
// Add the "Mouse focus mode" pop up menu
fFocusMenu = new BPopUpMenu(B_TRANSLATE("Click to focus and raise"));
const char *focusLabels[] = {B_TRANSLATE_MARK("Click to focus and raise"),
B_TRANSLATE_MARK("Click to focus"),
B_TRANSLATE_MARK("Focus follows mouse")};
const mode_mouse focusModes[] = {B_NORMAL_MOUSE, B_CLICK_TO_FOCUS_MOUSE,
B_FOCUS_FOLLOWS_MOUSE};
for (int i = 0; i < 3; i++) {
BMessage* message = new BMessage(kMsgMouseFocusMode);
message->AddInt32("mode", focusModes[i]);
fFocusMenu->AddItem(new BMenuItem(B_TRANSLATE_NOCOLLECT(focusLabels[i]),
message));
}
BMenuField* focusField = new BMenuField(B_TRANSLATE("Focus mode:"),
fFocusMenu);
focusField->SetAlignment(B_ALIGN_RIGHT);
// Add the "Focus follows mouse mode" pop up menu
fFocusFollowsMouseMenu = new BPopUpMenu(B_TRANSLATE("Normal"));
const char *focusFollowsMouseLabels[] = {B_TRANSLATE_MARK("Normal"),
B_TRANSLATE_MARK("Warp"), B_TRANSLATE_MARK("Instant warp")};
const mode_focus_follows_mouse focusFollowsMouseModes[] =
{B_NORMAL_FOCUS_FOLLOWS_MOUSE, B_WARP_FOCUS_FOLLOWS_MOUSE,
B_INSTANT_WARP_FOCUS_FOLLOWS_MOUSE};
for (int i = 0; i < 3; i++) {
BMessage* message = new BMessage(kMsgFollowsMouseMode);
message->AddInt32("mode_focus_follows_mouse",
focusFollowsMouseModes[i]);
fFocusFollowsMouseMenu->AddItem(new BMenuItem(
B_TRANSLATE_NOCOLLECT(focusFollowsMouseLabels[i]), message));
}
BMenuField* focusFollowsMouseField = new BMenuField(
"Focus follows mouse mode:", fFocusFollowsMouseMenu);
focusFollowsMouseField->SetAlignment(B_ALIGN_RIGHT);
// Add the "Click-through" check box
fAcceptFirstClickBox = new BCheckBox(B_TRANSLATE("Accept first click"),
new BMessage(kMsgAcceptFirstClick));
// dividers
BBox* hdivider = new BBox(
BRect(0, 0, 1, 1), B_EMPTY_STRING, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
hdivider->SetExplicitMaxSize(BSize(1, B_SIZE_UNLIMITED));
BBox* vdivider = new BBox(
BRect(0, 0, 1, 1), B_EMPTY_STRING, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
vdivider->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, 1));
// Build the layout
SetLayout(new BGroupLayout(B_HORIZONTAL));
AddChild(BGroupLayoutBuilder(B_VERTICAL, 10)
.AddGroup(B_HORIZONTAL, 10)
.AddGroup(B_VERTICAL, 10, 1)
.AddGroup(B_HORIZONTAL, 10)
.AddGlue()
.Add(typeField)
.AddGlue()
.End()
.AddGlue()
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 10)
.AddGlue()
.Add(fMouseView)
.AddGlue()
)
.AddGlue()
.Add(doubleClickTextControl)
.End()
.Add(hdivider)
.AddGroup(B_VERTICAL, 5, 3)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 0)
.Add(fClickSpeedSlider)
)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 0)
.Add(fMouseSpeedSlider)
)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 0)
.Add(fAccelerationSlider)
)
.End()
.End()
.Add(vdivider)
.AddGroup(B_HORIZONTAL, 10)
.Add(focusField)
.AddGlue()
.AddGroup(B_VERTICAL, 0)
.Add(fAcceptFirstClickBox)
.End()
.End()
.SetInsets(5, 5, 5, 5)
);
}
AttributeWindow::AttributeWindow(FileTypesWindow* target, BMimeType& mimeType,
AttributeItem* attributeItem)
: BWindow(BRect(100, 100, 350, 200), "Attribute", B_MODAL_WINDOW_LOOK,
B_MODAL_SUBSET_WINDOW_FEEL, B_NOT_ZOOMABLE | B_NOT_V_RESIZABLE
| B_ASYNCHRONOUS_CONTROLS),
fTarget(target),
fMimeType(mimeType.Type())
{
if (attributeItem != NULL)
fAttribute = *attributeItem;
BRect rect = Bounds();
BView* topView = new BView(rect, NULL, B_FOLLOW_ALL, B_WILL_DRAW);
topView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
AddChild(topView);
rect.InsetBy(8.0f, 8.0f);
fPublicNameControl = new BTextControl(rect, "public", "Attribute name:",
fAttribute.PublicName(), NULL, B_FOLLOW_LEFT_RIGHT);
fPublicNameControl->SetModificationMessage(new BMessage(kMsgAttributeUpdated));
float labelWidth = fPublicNameControl->StringWidth(fPublicNameControl->Label()) + 2.0f;
fPublicNameControl->SetDivider(labelWidth);
fPublicNameControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
float width, height;
fPublicNameControl->GetPreferredSize(&width, &height);
fPublicNameControl->ResizeTo(rect.Width(), height);
topView->AddChild(fPublicNameControl);
rect = fPublicNameControl->Frame();
rect.OffsetBy(0.0f, rect.Height() + 5.0f);
fAttributeControl = new BTextControl(rect, "internal", "Internal name:",
fAttribute.Name(), NULL, B_FOLLOW_LEFT_RIGHT);
fAttributeControl->SetModificationMessage(new BMessage(kMsgAttributeUpdated));
fAttributeControl->SetDivider(labelWidth);
fAttributeControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of an attribute
BTextView* textView = fAttributeControl->TextView();
const char* disallowedCharacters = "/";
for (int32 i = 0; disallowedCharacters[i]; i++) {
textView->DisallowChar(disallowedCharacters[i]);
}
topView->AddChild(fAttributeControl);
fTypeMenu = new BPopUpMenu("type");
BMenuItem* item = NULL;
for (int32 i = 0; kTypeMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgTypeChosen);
message->AddInt32("type", kTypeMap[i].type);
item = new BMenuItem(kTypeMap[i].name, message);
fTypeMenu->AddItem(item);
if (kTypeMap[i].type == fAttribute.Type())
item->SetMarked(true);
}
rect.OffsetBy(0.0f, rect.Height() + 4.0f);
BMenuField* menuField = new BMenuField(rect, "types",
"Type:", fTypeMenu);
menuField->SetDivider(labelWidth);
menuField->SetAlignment(B_ALIGN_RIGHT);
menuField->GetPreferredSize(&width, &height);
menuField->ResizeTo(rect.Width(), height);
topView->AddChild(menuField);
rect.OffsetBy(0.0f, rect.Height() + 4.0f);
rect.bottom = rect.top + fAttributeControl->Bounds().Height() * 2.0f + 18.0f;
BBox* box = new BBox(rect, "", B_FOLLOW_LEFT_RIGHT);
topView->AddChild(box);
fVisibleCheckBox = new BCheckBox(rect, "visible", "Visible",
new BMessage(kMsgVisibilityChanged));
fVisibleCheckBox->SetValue(fAttribute.Visible());
fVisibleCheckBox->ResizeToPreferred();
box->SetLabel(fVisibleCheckBox);
labelWidth -= 8.0f;
BMenu* menu = new BPopUpMenu("display as");
for (int32 i = 0; kDisplayAsMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgDisplayAsChosen);
if (kDisplayAsMap[i].identifier != NULL) {
message->AddString("identifier", kDisplayAsMap[i].identifier);
for (int32 j = 0; kDisplayAsMap[i].supported[j]; j++) {
message->AddInt32("supports", kDisplayAsMap[i].supported[j]);
}
}
item = new BMenuItem(kDisplayAsMap[i].name, message);
menu->AddItem(item);
if (compare_display_as(kDisplayAsMap[i].identifier, fAttribute.DisplayAs()))
item->SetMarked(true);
}
rect.OffsetTo(8.0f, fVisibleCheckBox->Bounds().Height());
rect.right -= 18.0f;
fDisplayAsMenuField = new BMenuField(rect, "display as",
"Display as:", menu);
fDisplayAsMenuField->SetDivider(labelWidth);
fDisplayAsMenuField->SetAlignment(B_ALIGN_RIGHT);
fDisplayAsMenuField->ResizeTo(rect.Width(), height);
box->AddChild(fDisplayAsMenuField);
fEditableCheckBox = new BCheckBox(rect, "editable", "Editable",
new BMessage(kMsgAttributeUpdated), B_FOLLOW_RIGHT);
fEditableCheckBox->SetValue(fAttribute.Editable());
fEditableCheckBox->ResizeToPreferred();
fEditableCheckBox->MoveTo(rect.right - fEditableCheckBox->Bounds().Width(),
rect.top + (fDisplayAsMenuField->Bounds().Height()
- fEditableCheckBox->Bounds().Height()) / 2.0f);
box->AddChild(fEditableCheckBox);
rect.OffsetBy(0.0f, menuField->Bounds().Height() + 4.0f);
rect.bottom = rect.top + fPublicNameControl->Bounds().Height();
fSpecialControl = new BTextControl(rect, "special", "Special:",
display_as_parameter(fAttribute.DisplayAs()), NULL,
B_FOLLOW_LEFT_RIGHT);
fSpecialControl->SetModificationMessage(new BMessage(kMsgAttributeUpdated));
fSpecialControl->SetDivider(labelWidth);
fSpecialControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fSpecialControl->SetEnabled(false);
box->AddChild(fSpecialControl);
char text[64];
snprintf(text, sizeof(text), "%ld", fAttribute.Width());
rect.OffsetBy(0.0f, fSpecialControl->Bounds().Height() + 4.0f);
fWidthControl = new BTextControl(rect, "width", "Width:",
text, NULL, B_FOLLOW_LEFT_RIGHT);
fWidthControl->SetModificationMessage(new BMessage(kMsgAttributeUpdated));
fWidthControl->SetDivider(labelWidth);
fWidthControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of a width
textView = fWidthControl->TextView();
for (int32 i = 0; i < 256; i++) {
if (!isdigit(i))
textView->DisallowChar(i);
}
textView->SetMaxBytes(4);
box->AddChild(fWidthControl);
const struct alignment_map {
int32 alignment;
const char* name;
} kAlignmentMap[] = {
{B_ALIGN_LEFT, "Left"},
{B_ALIGN_RIGHT, "Right"},
{B_ALIGN_CENTER, "Center"},
{0, NULL}
};
menu = new BPopUpMenu("alignment");
for (int32 i = 0; kAlignmentMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgAlignmentChosen);
message->AddInt32("alignment", kAlignmentMap[i].alignment);
item = new BMenuItem(kAlignmentMap[i].name, message);
menu->AddItem(item);
if (kAlignmentMap[i].alignment == fAttribute.Alignment())
item->SetMarked(true);
}
rect.OffsetBy(0.0f, menuField->Bounds().Height() + 1.0f);
fAlignmentMenuField = new BMenuField(rect, "alignment",
"Alignment:", menu);
fAlignmentMenuField->SetDivider(labelWidth);
fAlignmentMenuField->SetAlignment(B_ALIGN_RIGHT);
fAlignmentMenuField->ResizeTo(rect.Width(), height);
box->AddChild(fAlignmentMenuField);
box->ResizeBy(0.0f, fAlignmentMenuField->Bounds().Height() * 2.0f
+ fVisibleCheckBox->Bounds().Height());
fAcceptButton = new BButton(rect, "add", item ? "Done" : "Add",
new BMessage(kMsgAccept), B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM);
fAcceptButton->ResizeToPreferred();
fAcceptButton->MoveTo(Bounds().Width() - 8.0f - fAcceptButton->Bounds().Width(),
Bounds().Height() - 8.0f - fAcceptButton->Bounds().Height());
fAcceptButton->SetEnabled(false);
topView->AddChild(fAcceptButton);
BButton* button = new BButton(rect, "cancel", "Cancel",
new BMessage(B_QUIT_REQUESTED), B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM);
button->ResizeToPreferred();
button->MoveTo(fAcceptButton->Frame().left - 10.0f - button->Bounds().Width(),
fAcceptButton->Frame().top);
topView->AddChild(button);
ResizeTo(labelWidth * 4.0f + 24.0f, box->Frame().bottom
+ button->Bounds().Height() + 20.0f);
SetSizeLimits(fEditableCheckBox->Bounds().Width() + button->Bounds().Width()
+ fAcceptButton->Bounds().Width() + labelWidth + 24.0f,
32767.0f, Frame().Height(), Frame().Height());
fAcceptButton->MakeDefault(true);
fPublicNameControl->MakeFocus(true);
target->PlaceSubWindow(this);
AddToSubset(target);
}
ModifierKeysWindow::ModifierKeysWindow()
:
BWindow(BRect(0, 0, 360, 220), B_TRANSLATE("Modifier keys"),
B_FLOATING_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE
| B_AUTO_UPDATE_SIZE_LIMITS)
{
get_key_map(&fCurrentMap, &fCurrentBuffer);
get_key_map(&fSavedMap, &fSavedBuffer);
BStringView* keyRole = new BStringView("key role",
B_TRANSLATE_COMMENT("Role", "As in the role of a modifier key"));
keyRole->SetAlignment(B_ALIGN_RIGHT);
keyRole->SetFont(be_bold_font);
BStringView* keyLabel = new BStringView("key label",
B_TRANSLATE_COMMENT("Key", "As in a computer keyboard key"));
keyLabel->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
keyLabel->SetFont(be_bold_font);
BMenuField* shiftMenuField = _CreateShiftMenuField();
shiftMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* controlMenuField = _CreateControlMenuField();
controlMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* optionMenuField = _CreateOptionMenuField();
optionMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* commandMenuField = _CreateCommandMenuField();
commandMenuField->SetAlignment(B_ALIGN_RIGHT);
fShiftConflictView = new ConflictView("shift warning view");
fShiftConflictView->SetExplicitMaxSize(BSize(15, 15));
fControlConflictView = new ConflictView("control warning view");
fControlConflictView->SetExplicitMaxSize(BSize(15, 15));
fOptionConflictView = new ConflictView("option warning view");
fOptionConflictView->SetExplicitMaxSize(BSize(15, 15));
fCommandConflictView = new ConflictView("command warning view");
fCommandConflictView->SetExplicitMaxSize(BSize(15, 15));
fCancelButton = new BButton("cancelButton", B_TRANSLATE("Cancel"),
new BMessage(B_QUIT_REQUESTED));
fRevertButton = new BButton("revertButton", B_TRANSLATE("Revert"),
new BMessage(kMsgRevertModifiers));
fRevertButton->SetEnabled(false);
fOkButton = new BButton("okButton", B_TRANSLATE("Set modifier keys"),
new BMessage(kMsgApplyModifiers));
fOkButton->MakeDefault(true);
// Build the layout
SetLayout(new BGroupLayout(B_VERTICAL));
float forcedMinWidth = be_plain_font->StringWidth("XXX") * 4;
keyRole->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
BLayoutItem* shiftLabel = shiftMenuField->CreateLabelLayoutItem();
shiftLabel->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
BLayoutItem* controlLabel = controlMenuField->CreateLabelLayoutItem();
controlLabel->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
BLayoutItem* optionLabel = optionMenuField->CreateLabelLayoutItem();
optionLabel->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
BLayoutItem* commandLabel = commandMenuField->CreateLabelLayoutItem();
commandLabel->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
AddChild(BLayoutBuilder::Group<>(B_VERTICAL, B_USE_SMALL_SPACING)
.AddGroup(B_HORIZONTAL)
.Add(keyRole)
.Add(keyLabel)
.End()
.AddGroup(B_HORIZONTAL)
.Add(shiftLabel)
.Add(shiftMenuField->CreateMenuBarLayoutItem())
.Add(fShiftConflictView)
.End()
.AddGroup(B_HORIZONTAL)
.Add(controlLabel)
.Add(controlMenuField->CreateMenuBarLayoutItem())
.Add(fControlConflictView)
.End()
.AddGroup(B_HORIZONTAL)
.Add(optionLabel)
.Add(optionMenuField->CreateMenuBarLayoutItem())
.Add(fOptionConflictView)
.End()
.AddGroup(B_HORIZONTAL)
.Add(commandLabel)
.Add(commandMenuField->CreateMenuBarLayoutItem())
.Add(fCommandConflictView)
.End()
.AddGlue()
.AddGroup(B_HORIZONTAL)
.Add(fCancelButton)
.AddGlue()
.Add(fRevertButton)
.Add(fOkButton)
.End()
.SetInsets(B_USE_DEFAULT_SPACING)
);
_MarkMenuItems();
_ValidateDuplicateKeys();
PostMessage(kMsgHideShowIcons);
}
TPrefsWindow::TPrefsWindow(BRect rect, BFont *font, int32 *level,
bool *wrap, char **sig)
:BWindow(rect, "BeMail Preferences", B_TITLED_WINDOW,
B_NOT_CLOSABLE |
B_NOT_RESIZABLE |
B_NOT_ZOOMABLE)
{
BBox *box;
BFont menu_font;
BMenuField *menu;
BRect r;
fNewFont = font;
fFont = *fNewFont;
fNewLevel = level;
fLevel = *fNewLevel;
fNewWrap = wrap;
fWrap = *fNewWrap;
fNewSignature = sig;
fSignature = (char *)malloc(strlen(*fNewSignature) + 1);
strcpy(fSignature, *fNewSignature);
r = Bounds();
r.InsetBy(-1, -1);
box = new BBox(r);
AddChild(box);
r.Set(OK_BUTTON_X1, OK_BUTTON_Y1, OK_BUTTON_X2, OK_BUTTON_Y2);
fOK = new BButton(r, "ok", OK_BUTTON_TEXT, new BMessage(P_OK));
fOK->MakeDefault(true);
fOK->SetEnabled(false);
box->AddChild(fOK);
r.Set(CANCEL_BUTTON_X1, CANCEL_BUTTON_Y1, CANCEL_BUTTON_X2, CANCEL_BUTTON_Y2);
fCancel = new BButton(r, "cancel", CANCEL_BUTTON_TEXT, new BMessage(P_CANCEL));
box->AddChild(fCancel);
r.Set(REVERT_BUTTON_X1, REVERT_BUTTON_Y1, REVERT_BUTTON_X2, REVERT_BUTTON_Y2);
fRevert = new BButton(r, "revert", REVERT_BUTTON_TEXT, new BMessage(P_REVERT));
fRevert->SetEnabled(false);
box->AddChild(fRevert);
r.Set(FONT_X1, FONT_Y1, FONT_X2, FONT_Y2);
fFontMenu = BuildFontMenu(font);
menu = new BMenuField(r, "font", FONT_TEXT, fFontMenu,
B_FOLLOW_ALL,
B_WILL_DRAW |
B_NAVIGABLE |
B_NAVIGABLE_JUMP);
menu->GetFont(&menu_font);
menu->SetDivider(menu_font.StringWidth(WRAP_TEXT) + 7);
menu->SetAlignment(B_ALIGN_RIGHT);
box->AddChild(menu);
r.Set(SIZE_X1, SIZE_Y1, SIZE_X2, SIZE_Y2);
fSizeMenu = BuildSizeMenu(font);
menu = new BMenuField(r, "size", SIZE_TEXT, fSizeMenu,
B_FOLLOW_ALL,
B_WILL_DRAW |
B_NAVIGABLE |
B_NAVIGABLE_JUMP);
menu->SetDivider(menu_font.StringWidth(WRAP_TEXT) + 7);
menu->SetAlignment(B_ALIGN_RIGHT);
box->AddChild(menu);
r.Set(LEVEL_X1, LEVEL_Y1, LEVEL_X2, LEVEL_Y2);
fLevelMenu = BuildLevelMenu(*level);
menu = new BMenuField(r, "level", LEVEL_TEXT, fLevelMenu,
B_FOLLOW_ALL,
B_WILL_DRAW |
B_NAVIGABLE |
B_NAVIGABLE_JUMP);
menu->SetDivider(menu_font.StringWidth(WRAP_TEXT) + 7);
menu->SetAlignment(B_ALIGN_RIGHT);
box->AddChild(menu);
r.Set(WRAP_X1, WRAP_Y1, WRAP_X2, WRAP_Y2);
fWrapMenu = BuildWrapMenu(*wrap);
menu = new BMenuField(r, "wrap", WRAP_TEXT, fWrapMenu,
B_FOLLOW_ALL,
B_WILL_DRAW |
B_NAVIGABLE |
B_NAVIGABLE_JUMP);
menu->SetDivider(menu_font.StringWidth(WRAP_TEXT) + 7);
menu->SetAlignment(B_ALIGN_RIGHT);
box->AddChild(menu);
r.Set(SIG_X1, SIG_Y1, SIG_X2, SIG_Y2);
fSignatureMenu = BuildSignatureMenu(*sig);
menu = new BMenuField(r, "sig", SIGNATURE_TEXT, fSignatureMenu,
B_FOLLOW_ALL,
B_WILL_DRAW |
B_NAVIGABLE |
B_NAVIGABLE_JUMP);
menu->SetDivider(menu_font.StringWidth(WRAP_TEXT) + 7);
menu->SetAlignment(B_ALIGN_RIGHT);
box->AddChild(menu);
Show();
}
THeaderView::THeaderView(BRect rect, BRect windowRect, bool incoming,
bool resending, uint32 defaultCharacterSet, int32 defaultAccount)
:
BBox(rect, "m_header", B_FOLLOW_LEFT_RIGHT, B_WILL_DRAW, B_NO_BORDER),
fAccountMenu(NULL),
fEncodingMenu(NULL),
fAccountID(defaultAccount),
fAccountTo(NULL),
fAccount(NULL),
fBcc(NULL),
fCc(NULL),
fSubject(NULL),
fTo(NULL),
fDateLabel(NULL),
fDate(NULL),
fIncoming(incoming),
fCharacterSetUserSees(defaultCharacterSet),
fResending(resending),
fBccMenu(NULL),
fCcMenu(NULL),
fToMenu(NULL),
fEmailList(NULL)
{
BMenuField* field;
BMessage* msg;
float x = StringWidth( /* The longest title string in the header area */
B_TRANSLATE("Attachments: ")) + 9;
float y = TO_FIELD_V;
BMenuBar* dummy = new BMenuBar(BRect(0, 0, 100, 15), "Dummy");
AddChild(dummy);
float width, menuBarHeight;
dummy->GetPreferredSize(&width, &menuBarHeight);
dummy->RemoveSelf();
delete dummy;
float menuFieldHeight = menuBarHeight + 6;
float controlHeight = menuBarHeight + floorf(be_plain_font->Size() / 1.15);
if (!fIncoming) {
InitEmailCompletion();
InitGroupCompletion();
}
// Prepare the character set selection pop-up menu (we tell the user that
// it is the Encoding menu, even though it is really the character set).
// It may appear in the first line, to the right of the From box if the
// user is reading an e-mail. It appears on the second line, to the right
// of the e-mail account menu, if the user is composing a message. It lets
// the user quickly select a character set different from the application
// wide default one, and also shows them which character set is active. If
// you are reading a message, you also see an item that says "Automatic"
// for automatic decoding character set choice. It can slide around as the
// window is resized when viewing a message, but not when composing
// (because the adjacent pop-up menu can't resize dynamically due to a BeOS
// bug).
float widestCharacterSet = 0;
bool markedCharSet = false;
BMenuItem* item;
fEncodingMenu = new BPopUpMenu(B_EMPTY_STRING);
BCharacterSetRoster roster;
BCharacterSet charset;
while (roster.GetNextCharacterSet(&charset) == B_OK) {
BString name(charset.GetPrintName());
const char* mime = charset.GetMIMEName();
if (mime)
name << " (" << mime << ")";
uint32 convertID;
if (mime == NULL || strcasecmp(mime, "UTF-8") != 0)
convertID = charset.GetConversionID();
else
convertID = B_MAIL_UTF8_CONVERSION;
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", convertID);
fEncodingMenu->AddItem(item = new BMenuItem(name.String(), msg));
if (convertID == fCharacterSetUserSees && !markedCharSet) {
item->SetMarked(true);
markedCharSet = true;
}
if (StringWidth(name.String()) > widestCharacterSet)
widestCharacterSet = StringWidth(name.String());
}
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", B_MAIL_US_ASCII_CONVERSION);
fEncodingMenu->AddItem(item = new BMenuItem("US-ASCII", msg));
if (fCharacterSetUserSees == B_MAIL_US_ASCII_CONVERSION && !markedCharSet) {
item->SetMarked(true);
markedCharSet = true;
}
if (!resending && fIncoming) {
// reading a message, display the Automatic item
fEncodingMenu->AddSeparatorItem();
msg = new BMessage(kMsgEncoding);
msg->AddInt32("charset", B_MAIL_NULL_CONVERSION);
fEncodingMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Automatic"), msg));
if (!markedCharSet)
item->SetMarked(true);
}
// First line of the header, From for reading e-mails (includes the
// character set choice at the right), To when composing (nothing else in
// the row).
BRect r;
char string[20];
if (fIncoming && !resending) {
// Set up the character set pop-up menu on the right of "To" box.
r.Set (windowRect.Width() - widestCharacterSet -
StringWidth (B_TRANSLATE("Decoding:")) - 2 * SEPARATOR_MARGIN,
y - 2, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
field = new BMenuField (r, "decoding", B_TRANSLATE("Decoding:"),
fEncodingMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
field->SetDivider(field->StringWidth(B_TRANSLATE("Decoding:")) + 5);
AddChild(field);
r.Set(SEPARATOR_MARGIN, y,
field->Frame().left - SEPARATOR_MARGIN, y + menuFieldHeight);
sprintf(string, B_TRANSLATE("From:"));
} else {
r.Set(x - 12, y, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
string[0] = 0;
}
y += controlHeight;
fTo = new TTextControl(r, string, new BMessage(TO_FIELD), fIncoming,
resending, B_FOLLOW_LEFT_RIGHT);
fTo->SetFilter(mail_to_filter);
if (!fIncoming || resending) {
fTo->SetChoiceList(&fEmailList);
fTo->SetAutoComplete(true);
} else {
fTo->SetDivider(x - 12 - SEPARATOR_MARGIN);
fTo->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
}
AddChild(fTo);
msg = new BMessage(FIELD_CHANGED);
msg->AddInt32("bitmask", FIELD_TO);
fTo->SetModificationMessage(msg);
if (!fIncoming || resending) {
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
B_TRANSLATE("To:")) + 25);
r.top -= 1;
fToMenu = new QPopupMenu(B_TRANSLATE("To:"));
field = new BMenuField(r, "", "", fToMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
}
// "From:" accounts Menu and Encoding Menu.
if (!fIncoming || resending) {
// Put the character set box on the right of the From field.
r.Set(windowRect.Width() - widestCharacterSet -
StringWidth(B_TRANSLATE("Encoding:")) - 2 * SEPARATOR_MARGIN,
y - 2, windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
BMenuField* encodingField = new BMenuField(r, "encoding",
B_TRANSLATE("Encoding:"), fEncodingMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
encodingField->SetDivider(encodingField->StringWidth(
B_TRANSLATE("Encoding:")) + 5);
AddChild(encodingField);
field = encodingField;
// And now the "from account" pop-up menu, on the left side, taking the
// remaining space.
fAccountMenu = new BPopUpMenu(B_EMPTY_STRING);
BMailAccounts accounts;
bool marked = false;
for (int32 i = 0; i < accounts.CountAccounts(); i++) {
BMailAccountSettings* account = accounts.AccountAt(i);
BString name = account->Name();
name << ": " << account->RealName() << " <"
<< account->ReturnAddress() << ">";
msg = new BMessage(kMsgFrom);
BMenuItem *item = new BMenuItem(name, msg);
msg->AddInt32("id", account->AccountID());
if (defaultAccount == account->AccountID()) {
item->SetMarked(true);
marked = true;
}
fAccountMenu->AddItem(item);
}
if (!marked) {
BMenuItem *item = fAccountMenu->ItemAt(0);
if (item != NULL) {
item->SetMarked(true);
fAccountID = item->Message()->FindInt32("id");
} else {
fAccountMenu->AddItem(
item = new BMenuItem(B_TRANSLATE("<none>"), NULL));
item->SetEnabled(false);
fAccountID = ~0UL;
}
// default account is invalid, set to marked
// TODO: do this differently, no casting and knowledge
// of TMailApp here....
if (TMailApp* app = dynamic_cast<TMailApp*>(be_app))
app->SetDefaultAccount(fAccountID);
}
r.Set(SEPARATOR_MARGIN, y - 2,
field->Frame().left - SEPARATOR_MARGIN, y + menuFieldHeight);
field = new BMenuField(r, "account", B_TRANSLATE("From:"),
fAccountMenu, true /* fixedSize */,
B_FOLLOW_TOP | B_FOLLOW_LEFT_RIGHT,
B_WILL_DRAW | B_NAVIGABLE | B_NAVIGABLE_JUMP);
AddChild(field, encodingField);
field->SetDivider(x - 12 - SEPARATOR_MARGIN + kMenuFieldDividerOffset);
field->SetAlignment(B_ALIGN_RIGHT);
y += controlHeight;
} else {
// To: account
bool account = BMailAccounts().CountAccounts() > 0;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
if (account)
r.right -= SEPARATOR_MARGIN + ACCOUNT_FIELD_WIDTH;
fAccountTo = new TTextControl(r, B_TRANSLATE("To:"), NULL, fIncoming,
false, B_FOLLOW_LEFT_RIGHT);
fAccountTo->SetEnabled(false);
fAccountTo->SetDivider(x - 12 - SEPARATOR_MARGIN);
fAccountTo->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
AddChild(fAccountTo);
if (account) {
r.left = r.right + 6; r.right = windowRect.Width() - SEPARATOR_MARGIN;
fAccount = new TTextControl(r, B_TRANSLATE("Account:"), NULL,
fIncoming, false, B_FOLLOW_RIGHT | B_FOLLOW_TOP);
fAccount->SetEnabled(false);
AddChild(fAccount);
}
y += controlHeight;
}
if (fIncoming) {
--y;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fCc = new TTextControl(r, B_TRANSLATE("Cc:"),
NULL, fIncoming, false, B_FOLLOW_LEFT_RIGHT);
fCc->SetEnabled(false);
fCc->SetDivider(x - 12 - SEPARATOR_MARGIN);
fCc->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
AddChild(fCc);
}
--y;
r.Set(SEPARATOR_MARGIN, y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fSubject = new TTextControl(r, B_TRANSLATE("Subject:"),
new BMessage(SUBJECT_FIELD),fIncoming, false, B_FOLLOW_LEFT_RIGHT);
AddChild(fSubject);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_SUBJECT);
fSubject->SetModificationMessage(msg);
fSubject->SetDivider(x - 12 - SEPARATOR_MARGIN);
fSubject->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
if (fResending)
fSubject->SetEnabled(false);
--y;
if (!fIncoming) {
r.Set(x - 12, y, CC_FIELD_H + CC_FIELD_WIDTH, y + menuFieldHeight);
fCc = new TTextControl(r, "", new BMessage(CC_FIELD), fIncoming, false);
fCc->SetFilter(mail_to_filter);
fCc->SetChoiceList(&fEmailList);
fCc->SetAutoComplete(true);
AddChild(fCc);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_CC);
fCc->SetModificationMessage(msg);
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
B_TRANSLATE("Cc:")) + 25);
r.top -= 1;
fCcMenu = new QPopupMenu(B_TRANSLATE("Cc:"));
field = new BMenuField(r, "", "", fCcMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
r.Set(BCC_FIELD_H + be_plain_font->StringWidth(B_TRANSLATE("Bcc:")), y,
windowRect.Width() - SEPARATOR_MARGIN, y + menuFieldHeight);
y += controlHeight;
fBcc = new TTextControl(r, "", new BMessage(BCC_FIELD),
fIncoming, false, B_FOLLOW_LEFT_RIGHT);
fBcc->SetFilter(mail_to_filter);
fBcc->SetChoiceList(&fEmailList);
fBcc->SetAutoComplete(true);
AddChild(fBcc);
(msg = new BMessage(FIELD_CHANGED))->AddInt32("bitmask", FIELD_BCC);
fBcc->SetModificationMessage(msg);
r.right = r.left - 5;
r.left = r.right - ceilf(be_plain_font->StringWidth(
B_TRANSLATE("Bcc:")) + 25);
r.top -= 1;
fBccMenu = new QPopupMenu(B_TRANSLATE("Bcc:"));
field = new BMenuField(r, "", "", fBccMenu, true,
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
field->SetDivider(0.0);
field->SetEnabled(true);
AddChild(field);
} else {
y -= SEPARATOR_MARGIN;
r.Set(SEPARATOR_MARGIN, y, x - 12 - 1, y + menuFieldHeight);
fDateLabel = new BStringView(r, "", kDateLabel);
fDateLabel->SetAlignment(B_ALIGN_RIGHT);
AddChild(fDateLabel);
fDateLabel->SetHighColor(0, 0, 0);
r.Set(r.right + 9, y, windowRect.Width() - SEPARATOR_MARGIN,
y + menuFieldHeight);
fDate = new BStringView(r, "", "");
AddChild(fDate);
fDate->SetHighColor(0, 0, 0);
y += controlHeight + 5;
}
ResizeTo(Bounds().Width(), y);
}
void
AddPrinterDialog::_BuildGUI(int stage)
{
// add a "printer name" input field
fName = new BTextControl("printer_name", B_TRANSLATE("Printer name:"),
B_EMPTY_STRING, NULL);
fName->SetFont(be_bold_font);
fName->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fName->SetModificationMessage(new BMessage(kNameChangedMsg));
// add a "driver" popup menu field
fPrinter = new BPopUpMenu(B_TRANSLATE("<pick one>"));
BMenuField *printerMenuField = new BMenuField("drivers_list",
B_TRANSLATE("Printer type:"), fPrinter);
printerMenuField->SetAlignment(B_ALIGN_RIGHT);
_FillMenu(fPrinter, "Print", kPrinterSelectedMsg);
// add a "connected to" (aka transports list) menu field
fTransport = new BPopUpMenu(B_TRANSLATE("<pick one>"));
BMenuField *transportMenuField = new BMenuField("transports_list",
B_TRANSLATE("Connected to:"), fTransport);
transportMenuField->SetAlignment(B_ALIGN_RIGHT);
_FillTransportMenu(fTransport);
// add a "OK" button
fOk = new BButton(NULL, B_TRANSLATE("Add"), new BMessage((uint32)B_OK),
B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM);
// add a "Cancel button
BButton *cancel = new BButton(NULL, B_TRANSLATE("Cancel"),
new BMessage(B_CANCEL));
SetLayout(new BGridLayout());
AddChild(BGridLayoutBuilder(0, 4)
.Add(fName->CreateLabelLayoutItem(), 0, 0)
.Add(fName->CreateTextViewLayoutItem(), 1, 0)
.Add(printerMenuField->CreateLabelLayoutItem(), 0, 1)
.Add(printerMenuField->CreateMenuBarLayoutItem(), 1, 1)
.Add(transportMenuField->CreateLabelLayoutItem(), 0, 2)
.Add(transportMenuField->CreateMenuBarLayoutItem(), 1, 2)
.Add(BGroupLayoutBuilder(B_HORIZONTAL)
.AddGlue()
.Add(cancel)
.Add(fOk)
, 0, 3, 2)
.SetInsets(8, 8, 8, 8)
);
SetDefaultButton(fOk);
fOk->MakeDefault(true);
fName->MakeFocus(true);
_Update();
// Stage == 0
// init_icon 64x114 Add a Local or Network Printer
// ------------------------------
// I would like to add a...
// Local Printer
// Network Printer
// ------------------------------------------------
// Cancel Continue
// Add local printer:
// Stage == 1
// local_icon Add a Local Printer
// ------------------------------
// Printer Name: ________________
// Printer Type: pick one
// Connected to: pick one
// ------------------------------------------------
// Cancel Add
// This seems to be hard coded into the preferences dialog:
// Don't show Network transport add-on in Printer Type menu.
// If Printer Type == Preview disable Connect to popup menu.
// If Printer Type == Serial Port add a submenu to menu item
// with names in /dev/ports (if empty remove item from menu)
// If Printer Type == Parallel Port add a submenu to menu item
// with names in /dev/parallel (if empty remove item from menu)
// Printer Driver Setup
// Dialog Info
// Would you like to make X the default printer?
// No Yes
// Add network printer:
// Dialog Info
// Apple Talk networking isn't currenty enabled. If you
// wish to install a network printer you should enable
// AppleTalk in the Network preferences.
// Cancel Open Network
// Stage == 2
// network_icon Add a Network Printer
// ------------------------------
// Printer Name: ________________
// Printer Type: pick one
// AppleTalk Printer: pick one
// ------------------------------------------------
// Cancel Add
}
AttributeWindow::AttributeWindow(FileTypesWindow* target, BMimeType& mimeType,
AttributeItem* attributeItem)
:
BWindow(BRect(100, 100, 350, 200), B_TRANSLATE("Attribute"),
B_MODAL_WINDOW_LOOK, B_MODAL_SUBSET_WINDOW_FEEL,
B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS | B_ASYNCHRONOUS_CONTROLS),
fTarget(target),
fMimeType(mimeType.Type())
{
float padding = be_control_look->DefaultItemSpacing();
if (attributeItem != NULL)
fAttribute = *attributeItem;
fPublicNameControl = new BTextControl(B_TRANSLATE("Attribute name:"),
fAttribute.PublicName(), NULL);
fPublicNameControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fPublicNameControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fAttributeControl = new BTextControl(B_TRANSLATE("Internal name:"),
fAttribute.Name(), NULL);
fAttributeControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fAttributeControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of an attribute
BTextView* textView = fAttributeControl->TextView();
const char* disallowedCharacters = "/";
for (int32 i = 0; disallowedCharacters[i]; i++) {
textView->DisallowChar(disallowedCharacters[i]);
}
fTypeMenu = new BPopUpMenu("type");
BMenuItem* item = NULL;
for (int32 i = 0; kTypeMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgTypeChosen);
message->AddInt32("type", kTypeMap[i].type);
item = new BMenuItem(kTypeMap[i].name, message);
fTypeMenu->AddItem(item);
if (kTypeMap[i].type == fAttribute.Type())
item->SetMarked(true);
}
BMenuField* typeMenuField = new BMenuField("types" , B_TRANSLATE("Type:"),
fTypeMenu);
typeMenuField->SetAlignment(B_ALIGN_RIGHT);
// we must set the color manually when adding a menuField directly
// into a window.
typeMenuField->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
typeMenuField->SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fVisibleCheckBox = new BCheckBox("visible", B_TRANSLATE("Visible"),
new BMessage(kMsgVisibilityChanged));
fVisibleCheckBox->SetValue(fAttribute.Visible());
BMenu* menu = new BPopUpMenu("display as");
for (int32 i = 0; kDisplayAsMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgDisplayAsChosen);
if (kDisplayAsMap[i].identifier != NULL) {
message->AddString("identifier", kDisplayAsMap[i].identifier);
for (int32 j = 0; kDisplayAsMap[i].supported[j]; j++) {
message->AddInt32("supports", kDisplayAsMap[i].supported[j]);
}
}
item = new BMenuItem(kDisplayAsMap[i].name, message);
menu->AddItem(item);
if (compare_display_as(kDisplayAsMap[i].identifier,
fAttribute.DisplayAs()))
item->SetMarked(true);
}
fDisplayAsMenuField = new BMenuField("display as",
B_TRANSLATE_COMMENT("Display as:",
"Tracker offers different display modes for attributes."), menu);
fDisplayAsMenuField->SetAlignment(B_ALIGN_RIGHT);
fEditableCheckBox = new BCheckBox("editable",
B_TRANSLATE_COMMENT("Editable",
"If Tracker allows to edit this attribute."),
new BMessage(kMsgAttributeUpdated));
fEditableCheckBox->SetValue(fAttribute.Editable());
fSpecialControl = new BTextControl(B_TRANSLATE("Special:"),
display_as_parameter(fAttribute.DisplayAs()), NULL);
fSpecialControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fSpecialControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fSpecialControl->SetEnabled(false);
char text[64];
snprintf(text, sizeof(text), "%ld", fAttribute.Width());
fWidthControl = new BTextControl(B_TRANSLATE_COMMENT("Width:",
"Default column width in Tracker for this attribute."),
text, NULL);
fWidthControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fWidthControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of a width
textView = fWidthControl->TextView();
for (int32 i = 0; i < 256; i++) {
if (!isdigit(i))
textView->DisallowChar(i);
}
textView->SetMaxBytes(4);
const struct alignment_map {
int32 alignment;
const char* name;
} kAlignmentMap[] = {
{B_ALIGN_LEFT, B_TRANSLATE_COMMENT("Left",
"Attribute column alignment in Tracker")},
{B_ALIGN_RIGHT, B_TRANSLATE_COMMENT("Right",
"Attribute column alignment in Tracker")},
{B_ALIGN_CENTER, B_TRANSLATE_COMMENT("Center",
"Attribute column alignment in Tracker")},
{0, NULL}
};
menu = new BPopUpMenu("alignment");
for (int32 i = 0; kAlignmentMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgAlignmentChosen);
message->AddInt32("alignment", kAlignmentMap[i].alignment);
item = new BMenuItem(kAlignmentMap[i].name, message);
menu->AddItem(item);
if (kAlignmentMap[i].alignment == fAttribute.Alignment())
item->SetMarked(true);
}
fAlignmentMenuField = new BMenuField("alignment",
B_TRANSLATE("Alignment:"), menu);
fAlignmentMenuField->SetAlignment(B_ALIGN_RIGHT);
fAcceptButton = new BButton("add",
item ? B_TRANSLATE("Done") : B_TRANSLATE("Add"),
new BMessage(kMsgAccept));
fAcceptButton->SetEnabled(false);
BButton* cancelButton = new BButton("cancel", B_TRANSLATE("Cancel"),
new BMessage(B_QUIT_REQUESTED));
BBox* visibleBox;
BLayoutBuilder::Group<>(this, B_VERTICAL, padding)
.SetInsets(padding, padding, padding, padding)
.AddGrid(padding, padding / 2)
.Add(fPublicNameControl->CreateLabelLayoutItem(), 0, 0)
.Add(fPublicNameControl->CreateTextViewLayoutItem(), 1, 0)
.Add(fAttributeControl->CreateLabelLayoutItem(), 0, 1)
.Add(fAttributeControl->CreateTextViewLayoutItem(), 1, 1)
.Add(typeMenuField->CreateLabelLayoutItem(), 0, 2)
.Add(typeMenuField->CreateMenuBarLayoutItem(), 1, 2)
.End()
.Add(visibleBox = new BBox(B_FANCY_BORDER,
BLayoutBuilder::Grid<>(padding, padding / 2)
.Add(fDisplayAsMenuField->CreateLabelLayoutItem(), 0, 0)
.Add(fDisplayAsMenuField->CreateMenuBarLayoutItem(), 1, 0)
.Add(fEditableCheckBox, 2, 0)
.Add(fSpecialControl->CreateLabelLayoutItem(), 0, 1)
.Add(fSpecialControl->CreateTextViewLayoutItem(), 1, 1, 2)
.Add(fWidthControl->CreateLabelLayoutItem(), 0, 2)
.Add(fWidthControl->CreateTextViewLayoutItem(), 1, 2, 2)
.Add(fAlignmentMenuField->CreateLabelLayoutItem(), 0, 3)
.Add(fAlignmentMenuField->CreateMenuBarLayoutItem(), 1, 3, 2)
.SetInsets(padding, padding, padding, padding)
.View())
)
.AddGroup(B_HORIZONTAL, padding)
.Add(BSpaceLayoutItem::CreateGlue())
.Add(cancelButton)
.Add(fAcceptButton);
visibleBox->SetLabel(fVisibleCheckBox);
fAcceptButton->MakeDefault(true);
fPublicNameControl->MakeFocus(true);
target->PlaceSubWindow(this);
AddToSubset(target);
_CheckDisplayAs();
_CheckAcceptable();
}
/**
* @brief Creates child views.
*/
void BePreferencesDlg::createViews()
{
BeDialogControlHelper dch(getDialogLayout());
NativeStringLoader* nsl = CoveredCalcApp::GetInstance();
rgb_color viewColor = { 216, 216, 216, 255 };
rgb_color highColor = { 0, 0, 0, 255 };
// dialog title
SetTitle(nsl->LoadNativeString(NSID_PREFERENCES_TITLE));
// BaseView
BView* baseView = new BView(Bounds(), PREFERENCES_DIALOG_VIEW_BASE_VIEW,
B_FOLLOW_ALL_SIDES, B_WILL_DRAW);
AddChild(baseView);
baseView->SetViewColor(viewColor);
// LangBox
MBCString itemnameLangBox = ALITERAL("IDC_GROUP_LANGUAGE");
BBox* langBox = new BBox(dch.GetItemRect(itemnameLangBox, ITEMNAME_WINDOW), PREFERENCES_DIALOG_VIEW_LANG_BOX);
baseView->AddChild(langBox);
langBox->SetLabel(nsl->LoadNativeString(NSID_PREFERENCES_GROUP_LANGUAGE));
// LangPopup
langMenu = new BMenu("");
langMenu->SetLabelFromMarked(true);
BMenuField* langPopup = new BMenuField(dch.GetItemRect(ALITERAL("IDC_CMB_LANGUAGE"), itemnameLangBox), PREFERENCES_DIALOG_VIEW_LANG_POPUP,
nsl->LoadNativeString(NSID_PREFERENCES_LANGUAGE), langMenu);
langBox->AddChild(langPopup);
langPopup->SetDivider(dch.GetItemPos(true, ALITERAL("IDC_CMB_LANGUAGE.divider"), ALITERAL("IDC_CMB_LANGUAGE.left")));
langPopup->SetAlignment(B_ALIGN_LEFT);
uicLanguageListBox.Init(langPopup, ID_NULL);
// LangNotice
BRect frameRect = dch.GetItemRect(ALITERAL("IDC_STATIC_LANGUAGE_MESSAGE"), itemnameLangBox);
BRect textRect = frameRect;
textRect.OffsetTo(0, 0);
BTextView* langNotice = new BTextView(frameRect, PREFERENCES_DIALOG_VIEW_LANG_NOTICE,
textRect, B_FOLLOW_LEFT | B_FOLLOW_TOP);
langBox->AddChild(langNotice);
const char* text = nsl->LoadNativeString(NSID_PREFERENCES_LANGUAGE_MESSAGE);
langNotice->SetText(text);
langNotice->SetFontAndColor(0, strlen(text), be_plain_font, B_FONT_ALL, &highColor);
langNotice->SetViewColor(viewColor);
langNotice->MakeEditable(false);
// KeyMappingBox
MBCString itemnameKeyMappingBox = ALITERAL("IDC_GROUP_KEYMAP");
BBox* keyMappingBox = new BBox(dch.GetItemRect(itemnameKeyMappingBox, ITEMNAME_WINDOW), PREFERENCES_DIALOG_VIEW_KEYMAPPING_BOX);
baseView->AddChild(keyMappingBox);
keyMappingBox->SetLabel(nsl->LoadNativeString(NSID_PREFERENCES_GROUP_KEYMAP));
// KeyMappingPopup
BMenu* keyMappingMenu = new BMenu("");
keyMappingMenu->SetLabelFromMarked(true);
BMenuField* keyMappingPopup = new BMenuField(dch.GetItemRect(ALITERAL("IDC_CMB_KEYMAPPINGS"), itemnameKeyMappingBox), PREFERENCES_DIALOG_VIEW_KEYMAPPING_POPUP,
nsl->LoadNativeString(NSID_PREFERENCES_KEYMAP), keyMappingMenu);
keyMappingBox->AddChild(keyMappingPopup);
keyMappingPopup->SetDivider(dch.GetItemPos(true, ALITERAL("IDC_CMB_KEYMAPPINGS.divider"), ALITERAL("IDC_CMB_KEYMAPPINGS.left")));
keyMappingPopup->SetAlignment(B_ALIGN_LEFT);
uicKeyMapListBox.Init(keyMappingPopup, ID_PREF_KEYMAP_SELECTED);
// EditKeyMappingButton
BButton* editKeymapButton = new BButton(dch.GetItemRect(ALITERAL("IDC_EDIT_KEYMAPPING"), itemnameKeyMappingBox), PREFERENCES_DIALOG_VIEW_EDIT_KEYMAPPING_BUTTON,
nsl->LoadNativeString(NSID_PREFERENCES_EDIT_KEYMAP), new BMessage(ID_PREF_EDIT_KEYMAP));
keyMappingBox->AddChild(editKeymapButton);
uicEditKeyMapButton.Init(editKeymapButton);
// DuplicateKeyMappingButton
BButton* dupKeymapButton = new BButton(dch.GetItemRect(ALITERAL("IDC_DUPLICATE_KEYMAPPING"), itemnameKeyMappingBox), PREFERENCES_DIALOG_VIEW_DUPLICATE_KEYMAPPING_BUTTON,
nsl->LoadNativeString(NSID_PREFERENCES_DUPLICATE_KEYMAP), new BMessage(ID_PREF_DUPLICATE_KEYMAP));
keyMappingBox->AddChild(dupKeymapButton);
uicDuplicateKeyMapButton.Init(dupKeymapButton);
// DeleteKeyMappingButton
BButton* delKeymapButton = new BButton(dch.GetItemRect(ALITERAL("IDC_DELETE_KEYMAPPING"), itemnameKeyMappingBox), PREFERENCES_DIALOG_VIEW_DELETE_KEYMAPPING_BUTTON,
nsl->LoadNativeString(NSID_PREFERENCES_DELETE_KEYMAP), new BMessage(ID_PREF_DELETE_KEYMAP));
keyMappingBox->AddChild(delKeymapButton);
uicDeleteKeyMapButton.Init(delKeymapButton);
// CancelButton
BButton* cancelButton = new BButton(dch.GetItemRect(ALITERAL("IDCANCEL"), ITEMNAME_WINDOW), PREFERENCES_DIALOG_VIEW_CANCEL,
nsl->LoadNativeString(NSID_PREFERENCES_CANCEL), new BMessage(ID_DIALOG_CANCEL));
baseView->AddChild(cancelButton);
// OKButton
BButton* okButton = new BButton(dch.GetItemRect(ALITERAL("IDOK"), ITEMNAME_WINDOW), PREFERENCES_DIALOG_VIEW_OK,
nsl->LoadNativeString(NSID_PREFERENCES_OK), new BMessage(ID_DIALOG_OK));
baseView->AddChild(okButton);
SetDefaultButton(okButton);
}