void SplitWindow::AddCat()
{
ResizeBy(0, 25);
uint16 xpos = 20;
uint16 width = 150;
BTextControl* tc = new BTextControl(BRect(xpos - 5, ypos + 10,
xpos + width, ypos + 10), "CatField", "", "", 0);
xpos += width;
tc->SetDivider(0);
catTexts.push_back(tc);
v->AddChild(tc);
BPopUpMenu* pu = new BPopUpMenu("", true, false);
BMenuField* mf = new BMenuField(BRect(xpos + 2, ypos + 9,
xpos + 2, ypos + 9), "CatMenu", "", pu);
mf->SetDivider(0);
v->AddChild(mf);
xpos += 30;
tc = new BTextControl(BRect(xpos - 5, ypos + 10,
xpos + 75, ypos + 10), "AmountField", "", "", 0);
tc->SetDivider(0);
tc->SetAlignment(B_ALIGN_LEFT, B_ALIGN_RIGHT);
tc->SetModificationMessage(new BMessage(AmountModifiedMSG));
amtTexts.push_back(tc);
v->AddChild(tc);
ypos += 25;
for (cas::iterator ci = catS->begin(); ci != catS->end(); ci++)
{
if ((*ci)->IsRoot())
{
pu->AddItem(MakeCatMenu(*ci));
}
}
catnum++;
}
quadruplet<BTextControl*, BPopUpMenu*, BMenuField*, BStringView*> CheckView::MakeField(uint16 width,
string name, uint16* xpos, uint16* ypos)
{
BStringView* sv = new BStringView(BRect((*xpos), (*ypos),
(*xpos) + width, (*ypos) + 10),
(name + "Text").c_str(), name.c_str());
BFont font;
sv->GetFont(&font);
font.SetSize(10);
sv->SetFont(&font);
AddChild(sv);
BTextControl* tc = new BTextControl(BRect((*xpos) - 5, (*ypos) + 10,
(*xpos) + width, (*ypos) + 10), (name + "Field").c_str(),
"", "", 0);
(*xpos) += width;
tc->SetDivider(0);
AddChild(tc);
BPopUpMenu* pu = new BPopUpMenu("", true, false);
BMenuField* mf = new BMenuField(BRect((*xpos) + 2, (*ypos) + 9,
(*xpos) + 2, (*ypos) + 9), (name + "Menu").c_str(), "", pu);
mf->SetDivider(0);
AddChild(mf);
(*xpos) += 30;
return quadruplet<BTextControl*, BPopUpMenu*, BMenuField*, BStringView*>(tc, pu, mf, sv);
}
ConfigView::ConfigView()
: BView(BRect(0,0,10,10),"notifier_config",B_FOLLOW_LEFT | B_FOLLOW_TOP,0)
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
// determine font height
font_height fontHeight;
GetFontHeight(&fontHeight);
float itemHeight = (int32)(fontHeight.ascent + fontHeight.descent + fontHeight.leading) + 6;
BRect frame(5,2,250,itemHeight + 2);
BPopUpMenu *menu = new BPopUpMenu(B_EMPTY_STRING,false,false);
const char *notifyMethods[] = {
MDR_DIALECT_CHOICE ("Beep","音"),
MDR_DIALECT_CHOICE ("Alert","窓（メール毎）"),
MDR_DIALECT_CHOICE ("Keyboard LEDs","キーボードLED"),
MDR_DIALECT_CHOICE ("Central alert","窓（一括）"),
"Central beep","Log window"};
for (int32 i = 0,j = 1;i < 6;i++,j *= 2)
menu->AddItem(new BMenuItem(notifyMethods[i],new BMessage(kMsgNotifyMethod)));
BMenuField *field = new BMenuField(frame,"notify",
MDR_DIALECT_CHOICE ("Method:","方法："),menu);
field->ResizeToPreferred();
field->SetDivider(field->StringWidth(
MDR_DIALECT_CHOICE ("Method:","方法：")) + 6);
AddChild(field);
ResizeToPreferred();
}
SMTPConfigView::SMTPConfigView(MailAddonSettings& settings,
BMailAccountSettings& accountSettings)
:
BMailProtocolConfigView(B_MAIL_PROTOCOL_HAS_AUTH_METHODS
| B_MAIL_PROTOCOL_HAS_USERNAME | B_MAIL_PROTOCOL_HAS_PASSWORD
| B_MAIL_PROTOCOL_HAS_HOSTNAME
#ifdef USE_SSL
| B_MAIL_PROTOCOL_HAS_FLAVORS
#endif
)
{
#if defined(USE_SSL) || defined(B_COLLECTING_CATKEYS)
static const char* kUnencryptedStr = B_TRANSLATE_MARK("Unencrypted");
static const char* kSSLStr = B_TRANSLATE_MARK("SSL");
static const char* kSTARTTLSStr = B_TRANSLATE_MARK("STARTTLS");
#endif
#ifdef USE_SSL
AddFlavor(B_TRANSLATE_NOCOLLECT(kUnencryptedStr));
AddFlavor(B_TRANSLATE(kSSLStr));
AddFlavor(B_TRANSLATE(kSTARTTLSStr));
#endif
AddAuthMethod(B_TRANSLATE("None"), false);
AddAuthMethod(B_TRANSLATE("ESMTP"));
AddAuthMethod(B_TRANSLATE("POP3 before SMTP"), false);
BTextControl *control = (BTextControl *)(FindView("host"));
control->SetLabel(B_TRANSLATE("SMTP server:"));
// Reset the dividers after changing one
float widestLabel = 0;
for (int32 i = CountChildren(); i-- > 0;) {
if (BTextControl *text = dynamic_cast<BTextControl *>(ChildAt(i)))
widestLabel = MAX(widestLabel,text->StringWidth(text->Label()) + 5);
}
for (int32 i = CountChildren(); i-- > 0;) {
if (BTextControl *text = dynamic_cast<BTextControl *>(ChildAt(i)))
text->SetDivider(widestLabel);
}
BMenuField *field = (BMenuField *)(FindView("auth_method"));
field->SetDivider(widestLabel);
SetTo(settings);
fFileView = new BMailFileConfigView(B_TRANSLATE("Destination:"), "path",
false, BPrivate::default_mail_out_directory().Path());
fFileView->SetTo(&settings.Settings(), NULL);
AddChild(fFileView);
float w, h;
BMailProtocolConfigView::GetPreferredSize(&w, &h);
fFileView->MoveBy(0, h - 10);
GetPreferredSize(&w, &h);
ResizeTo(w, h);
}
void
HWindow::_InitGUI()
{
fEventList = new HEventList();
fEventList->SetType(BMediaFiles::B_SOUNDS);
fEventList->SetSelectionMode(B_SINGLE_SELECTION_LIST);
BMenu* menu = new BMenu("file");
menu->SetRadioMode(true);
menu->SetLabelFromMarked(true);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("<none>"),
new BMessage(M_NONE_MESSAGE)));
menu->AddItem(new BMenuItem(B_TRANSLATE("Other" B_UTF8_ELLIPSIS),
new BMessage(M_OTHER_MESSAGE)));
BString label(B_TRANSLATE("Sound file:"));
BMenuField* menuField = new BMenuField("filemenu", label, menu);
menuField->SetDivider(menuField->StringWidth(label) + 10);
BSize buttonsSize(be_plain_font->Size() * 2.5, be_plain_font->Size() * 2.5);
BButton* stopbutton = new BButton("stop", "\xE2\x96\xA0",
new BMessage(M_STOP_MESSAGE));
stopbutton->SetEnabled(false);
stopbutton->SetExplicitSize(buttonsSize);
// We need at least one view to trigger B_PULSE_NEEDED events which we will
// intercept in DispatchMessage to trigger the buttons enabling or disabling.
stopbutton->SetFlags(stopbutton->Flags() | B_PULSE_NEEDED);
BButton* playbutton = new BButton("play", "\xE2\x96\xB6",
new BMessage(M_PLAY_MESSAGE));
playbutton->SetEnabled(false);
playbutton->SetExplicitSize(buttonsSize);
BLayoutBuilder::Group<>(this, B_VERTICAL)
.SetInsets(B_USE_WINDOW_SPACING)
.Add(fEventList)
.AddGroup(B_HORIZONTAL)
.Add(menuField)
.AddGroup(B_HORIZONTAL, 0)
.Add(playbutton)
.Add(stopbutton)
.End()
.End();
// setup file menu
_SetupMenuField();
BMenuItem* noneItem = menu->FindItem(B_TRANSLATE("<none>"));
if (noneItem != NULL)
noneItem->SetMarked(true);
_UpdateZoomLimits();
}
BooleanEditor::BooleanEditor(BRect rect, DataEditor &editor)
: TypeEditorView(rect, B_TRANSLATE("Boolean editor"), B_FOLLOW_NONE, 0, editor)
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
BPopUpMenu *menu = new BPopUpMenu("bool");
BMessage *message;
menu->AddItem(fFalseMenuItem = new BMenuItem("false",
new BMessage(kMsgValueChanged)));
menu->AddItem(fTrueMenuItem = new BMenuItem("true",
message = new BMessage(kMsgValueChanged)));
message->AddInt8("value", 1);
BMenuField *menuField = new BMenuField(rect.InsetByCopy(5, 5),
B_EMPTY_STRING, B_TRANSLATE("Boolean value:"), menu, B_FOLLOW_LEFT_RIGHT);
menuField->SetDivider(StringWidth(menuField->Label()) + 8);
menuField->ResizeToPreferred();
ResizeTo(menuField->Bounds().Width() + 10,
menuField->Bounds().Height() + 10);
_UpdateMenuField();
AddChild(menuField);
}
void
HWindow::InitGUI()
{
fEventList = new HEventList();
fEventList->SetType(BMediaFiles::B_SOUNDS);
fEventList->SetSelectionMode(B_SINGLE_SELECTION_LIST);
BGroupView* view = new BGroupView();
BBox* box = new BBox("", B_WILL_DRAW | B_FRAME_EVENTS
| B_NAVIGABLE_JUMP | B_PULSE_NEEDED);
BMenu* menu = new BMenu("file");
menu->SetRadioMode(true);
menu->SetLabelFromMarked(true);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("<none>"),
new BMessage(M_NONE_MESSAGE)));
menu->AddItem(new BMenuItem(B_TRANSLATE("Other" B_UTF8_ELLIPSIS),
new BMessage(M_OTHER_MESSAGE)));
BString label(B_TRANSLATE("Sound file:"));
BMenuField* menuField = new BMenuField("filemenu", label, menu);
menuField->SetDivider(menuField->StringWidth(label) + 10);
BButton* stopbutton = new BButton("stop", B_TRANSLATE("Stop"),
new BMessage(M_STOP_MESSAGE));
stopbutton->SetEnabled(false);
BButton* playbutton = new BButton("play", B_TRANSLATE("Play"),
new BMessage(M_PLAY_MESSAGE));
playbutton->SetEnabled(false);
const float kInset = be_control_look->DefaultItemSpacing();
view->SetLayout(new BGroupLayout(B_HORIZONTAL));
view->AddChild(BGroupLayoutBuilder(B_VERTICAL, kInset)
.AddGroup(B_HORIZONTAL)
.Add(menuField)
.AddGlue()
.End()
.AddGroup(B_HORIZONTAL, kInset)
.AddGlue()
.Add(playbutton)
.Add(stopbutton)
.End()
.SetInsets(kInset, kInset, kInset, kInset)
);
box->AddChild(view);
SetLayout(new BGroupLayout(B_HORIZONTAL));
AddChild(BGroupLayoutBuilder(B_VERTICAL)
.AddGroup(B_VERTICAL, kInset)
.Add(fEventList)
.Add(box)
.End()
.SetInsets(kInset, kInset, kInset, kInset)
);
// setup file menu
SetupMenuField();
BMenuItem* noneItem = menu->FindItem(B_TRANSLATE("<none>"));
if (noneItem != NULL)
noneItem->SetMarked(true);
}
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);
}
/**
* @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);
}
void
ControlView::AttachedToWindow()
{
BRect rect(Bounds());
rect.InsetBySelf(10, 0);
rect.bottom = rect.top + 18;
rect.OffsetBy(0, 11);
float offsetX = 0;
float offsetY = 0;
fTextControl = new BTextControl(rect, "TextInput", B_TRANSLATE("Text:"),
B_TRANSLATE("Haiku, Inc."), NULL);
fTextControl->SetDivider(29.0);
fTextControl->SetModificationMessage(new BMessage(TEXT_CHANGED_MSG));
AddChild(fTextControl);
rect.OffsetBy(0.0, 27.0);
_AddFontMenu(rect);
rect.OffsetBy(0.0, 29.0);
fFontsizeSlider = new BSlider(rect, "Fontsize", B_TRANSLATE("Size: 50"),
NULL, 4, 360);
fFontsizeSlider->SetModificationMessage(new BMessage(FONTSIZE_MSG));
fFontsizeSlider->SetValue(50);
AddChild(fFontsizeSlider);
// Get the preferred size for the sliders
fFontsizeSlider->GetPreferredSize(&offsetY, &offsetX);
offsetX += 1;
rect.OffsetBy(0.0, offsetX);
fShearSlider = new BSlider(rect, "Shear", B_TRANSLATE("Shear: 90"), NULL,
45, 135);
fShearSlider->SetModificationMessage(new BMessage(FONTSHEAR_MSG));
fShearSlider->SetValue(90);
AddChild(fShearSlider);
rect.OffsetBy(0.0, offsetX);
fRotationSlider = new BSlider(rect, "Rotation", B_TRANSLATE("Rotation: 0"),
NULL, 0, 360);
fRotationSlider->SetModificationMessage( new BMessage(ROTATION_MSG));
fRotationSlider->SetValue(0);
AddChild(fRotationSlider);
rect.OffsetBy(0.0, offsetX);
fSpacingSlider = new BSlider(rect, "Spacing", B_TRANSLATE("Spacing: 0"),
NULL, -5, 50);
fSpacingSlider->SetModificationMessage(new BMessage(SPACING_MSG));
fSpacingSlider->SetValue(0);
AddChild(fSpacingSlider);
rect.OffsetBy(0.0, offsetX);
fOutlineSlider = new BSlider(rect, "Outline", B_TRANSLATE("Outline:"),
NULL, 0, 20);
fOutlineSlider->SetModificationMessage(new BMessage(OUTLINE_MSG));
AddChild(fOutlineSlider);
rect.OffsetBy(0.0, offsetX);
fAliasingCheckBox = new BCheckBox(rect, "Aliasing",
B_TRANSLATE("Antialiased text"), new BMessage(ALIASING_MSG));
fAliasingCheckBox->SetValue(B_CONTROL_ON);
AddChild(fAliasingCheckBox);
rect.OffsetBy(0.0, offsetX);
fDrawingModeMenu = new BMenu("drawingmodemenu");
BMessage* drawingMsg = NULL;
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_COPY);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_COPY", drawingMsg));
fDrawingModeMenu->ItemAt(0)->SetMarked(true);
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_OVER);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_OVER", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_ERASE);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_ERASE", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_INVERT);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_INVERT", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_ADD);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_ADD", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_SUBTRACT);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_SUBTRACT", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_BLEND);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_BLEND", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_MIN);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_MIN", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_MAX);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_MAX", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_SELECT);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_SELECT", drawingMsg));
drawingMsg = new BMessage(DRAWINGMODE_CHANGED_MSG);
drawingMsg->AddInt32("_mode", B_OP_ALPHA);
fDrawingModeMenu->AddItem(new BMenuItem("B_OP_ALPHA", drawingMsg));
fDrawingModeMenu->SetLabelFromMarked(true);
BMenuField *drawingModeMenuField = new BMenuField(rect, "FontMenuField",
B_TRANSLATE("Drawing mode:"), fDrawingModeMenu, true);
drawingModeMenuField->SetDivider(5+StringWidth(
B_TRANSLATE("Drawing mode:")));
AddChild(drawingModeMenuField);
rect.OffsetBy(0.0, 22);
fBoundingboxesCheckBox = new BCheckBox(rect, "BoundingBoxes",
B_TRANSLATE("Bounding boxes"), new BMessage(BOUNDING_BOX_MSG));
AddChild(fBoundingboxesCheckBox);
rect.OffsetBy(0.0, 22.0);
fCyclingFontButton = new BButton(rect, "Cyclefonts",
B_TRANSLATE("Cycle fonts"), new BMessage(CYCLING_FONTS_MSG));
AddChild(fCyclingFontButton);
fTextControl->SetTarget(this);
fFontsizeSlider->SetTarget(this);
fShearSlider->SetTarget(this);
fRotationSlider->SetTarget(this);
fSpacingSlider->SetTarget(this);
fOutlineSlider->SetTarget(this);
fAliasingCheckBox->SetTarget(this);
fBoundingboxesCheckBox->SetTarget(this);
fCyclingFontButton->SetTarget(this);
}
void
PageSetupView::AttachedToWindow()
{
BMenuItem *item = NULL;
BMenuField *menuField;
BButton *button;
bool marked;
int count;
/* margin */
MarginUnit units = fJobData->getMarginUnit();
BRect paper = fJobData->getPaperRect();
BRect margin = fJobData->getPrintableRect();
// re-calculate the margin from the printable rect in points
margin.top -= paper.top;
margin.left -= paper.left;
margin.right = paper.right - margin.right;
margin.bottom = paper.bottom - margin.bottom;
fMarginView = new MarginView(MARGIN_RECT,
paper.IntegerWidth(),
paper.IntegerHeight(),
margin, units);
AddChild(fMarginView);
/* paper selection */
marked = false;
fPaper = new BPopUpMenu("");
fPaper->SetRadioMode(true);
count = fPrinterCap->countCap(PrinterCap::kPaper);
PaperCap **paper_cap = (PaperCap **)fPrinterCap->enumCap(PrinterCap::kPaper);
while (count--) {
BMessage *msg = new BMessage(kMsgPaperChanged);
msg->AddPointer("paperCap", *paper_cap);
item = new BMenuItem((*paper_cap)->label.c_str(), msg);
fPaper->AddItem(item);
item->SetTarget(this);
if ((*paper_cap)->paper == fJobData->getPaper()) {
item->SetMarked(true);
marked = true;
}
paper_cap++;
}
if (!marked)
item->SetMarked(true);
menuField = new BMenuField(PAPER_RECT, "", PAPER_TEXT, fPaper);
AddChild(menuField);
float width = StringWidth(PAPER_TEXT) + 7;
menuField->SetDivider(width);
/* orientaion */
fOrientation = new BPopUpMenu("orientation");
fOrientation->SetRadioMode(true);
menuField = new BMenuField(ORIENTATION_RECT, "orientation", ORIENTATION_TEXT, fOrientation);
menuField->SetDivider(width);
count = fPrinterCap->countCap(PrinterCap::kOrientation);
if (count == 0) {
AddOrientationItem(PORTRAIT_TEXT, JobData::kPortrait);
AddOrientationItem(LANDSCAPE_TEXT, JobData::kLandscape);
} else {
OrientationCap **orientation_cap = (OrientationCap **)fPrinterCap->enumCap(PrinterCap::kOrientation);
while (count--) {
AddOrientationItem((*orientation_cap)->label.c_str(),
(*orientation_cap)->orientation);
orientation_cap++;
}
}
AddChild(menuField);
/* resolution */
marked = false;
fResolution = new BPopUpMenu("");
fResolution->SetRadioMode(true);
count = fPrinterCap->countCap(PrinterCap::kResolution);
ResolutionCap **resolution_cap = (ResolutionCap **)fPrinterCap->enumCap(PrinterCap::kResolution);
while (count--) {
item = new BMenuItem((*resolution_cap)->label.c_str(), NULL);
fResolution->AddItem(item);
item->SetTarget(this);
if (((*resolution_cap)->xres == fJobData->getXres()) && ((*resolution_cap)->yres == fJobData->getYres())) {
item->SetMarked(true);
marked = true;
}
resolution_cap++;
}
if (!marked)
item->SetMarked(true);
menuField = new BMenuField(RESOLUTION_RECT, "", RES_TEXT, fResolution);
AddChild(menuField);
menuField->SetDivider(width);
/* scale */
BString scale;
scale << (int)fJobData->getScaling();
fScaling = new BTextControl(SCALE_RECT, "scale", "Scale [%]:",
scale.String(),
NULL, B_FOLLOW_RIGHT);
int num;
for (num = 0; num <= 255; num++) {
fScaling->TextView()->DisallowChar(num);
}
for (num = 0; num <= 9; num++) {
fScaling->TextView()->AllowChar('0' + num);
}
fScaling->TextView()->SetMaxBytes(3);
fScaling->SetDivider(width);
AddChild(fScaling);
/* cancel */
button = new BButton(CANCEL_RECT, "", CANCEL_TEXT, new BMessage(kMsgCancel));
AddChild(button);
/* ok */
button = new BButton(OK_RECT, "", OK_TEXT, new BMessage(kMsgOK));
AddChild(button);
button->MakeDefault(true);
}
/***********************************************************
* InitGUI
***********************************************************/
void
HAddressView::InitGUI()
{
float divider = StringWidth(_("Subject:")) + 20;
divider = max_c(divider , StringWidth(_("From:"))+20);
divider = max_c(divider , StringWidth(_("To:"))+20);
divider = max_c(divider , StringWidth(_("Bcc:"))+20);
BRect rect = Bounds();
rect.top += 5;
rect.left += 20 + divider;
rect.right = Bounds().right - 5;
rect.bottom = rect.top + 25;
BTextControl *ctrl;
ResourceUtils rutils;
const char* name[] = {"to","subject","from","cc","bcc"};
for(int32 i = 0;i < 5;i++)
{
ctrl = new BTextControl(BRect(rect.left,rect.top
,(i == 1)?rect.right+divider:rect.right
,rect.bottom)
,name[i],"","",NULL
,B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP,B_WILL_DRAW|B_NAVIGABLE);
if(i == 1)
{
ctrl->SetLabel(_("Subject:"));
ctrl->SetDivider(divider);
ctrl->MoveBy(-divider,0);
}else{
ctrl->SetDivider(0);
}
BMessage *msg = new BMessage(M_MODIFIED);
msg->AddPointer("pointer",ctrl);
ctrl->SetModificationMessage(msg);
ctrl->SetEnabled(!fReadOnly);
AddChild(ctrl);
rect.OffsetBy(0,25);
switch(i)
{
case 0:
fTo = ctrl;
break;
case 1:
fSubject = ctrl;
break;
case 2:
fFrom = ctrl;
fFrom->SetEnabled(false);
fFrom->SetFlags(fFrom->Flags() & ~B_NAVIGABLE);
break;
case 3:
fCc = ctrl;
break;
case 4:
fBcc = ctrl;
break;
}
}
//
BRect menuRect= Bounds();
menuRect.top += 5;
menuRect.left += 22;
menuRect.bottom = menuRect.top + 25;
menuRect.right = menuRect.left + 16;
BMenu *toMenu = new BMenu(_("To:"));
BMenu *ccMenu = new BMenu(_("Cc:"));
BMenu *bccMenu = new BMenu(_("Bcc:"));
BQuery query;
BVolume volume;
BVolumeRoster().GetBootVolume(&volume);
query.SetVolume(&volume);
query.SetPredicate("((META:email=*)&&(BEOS:TYPE=application/x-person))");
if(!fReadOnly && query.Fetch() == B_OK)
{
BString addr[4],name,group,nick;
entry_ref ref;
BList peopleList;
while(query.GetNextRef(&ref) == B_OK)
{
BNode node(&ref);
if(node.InitCheck() != B_OK)
continue;
ReadNodeAttrString(&node,"META:name",&name);
ReadNodeAttrString(&node,"META:email",&addr[0]);
ReadNodeAttrString(&node,"META:email2",&addr[1]);
ReadNodeAttrString(&node,"META:email3",&addr[2]);
ReadNodeAttrString(&node,"META:email4",&addr[3]);
ReadNodeAttrString(&node,"META:group",&group);
ReadNodeAttrString(&node,"META:nickname",&nick);
for(int32 i = 0;i < 4;i++)
{
if(addr[i].Length() > 0)
{
if(nick.Length() > 0)
{
nick += " <";
nick += addr[i];
nick += ">";
fAddrList.AddItem(strdup(nick.String()));
}
fAddrList.AddItem(strdup(addr[i].String()));
BString title = name;
title << " <" << addr[i] << ">";
AddPersonToList(peopleList,title.String(),group.String());
}
}
}
// Sort people data
peopleList.SortItems(HAddressView::SortPeople);
// Build menus
BTextControl *control[3] = {fTo,fCc,fBcc};
BMenu *menus[3] = {toMenu,ccMenu,bccMenu};
int32 count = peopleList.CountItems();
PersonData *data;
bool needSeparator = false;
bool hasSeparator = false;
for(int32 k = 0;k < 3;k++)
{
for(int32 i = 0;i < count;i++)
{
BMessage *msg = new BMessage(M_ADDR_MSG);
msg->AddPointer("pointer",control[k]);
data = (PersonData*)peopleList.ItemAt(i);
msg->AddString("email",data->email);
if(needSeparator && !hasSeparator && strlen(data->group) == 0)
{
menus[k]->AddSeparatorItem();
hasSeparator = true;
}else
needSeparator = true;
AddPerson(menus[k],data->email,data->group,msg,0,0);
}
hasSeparator = false;
needSeparator = false;
}
// free all data
while(count > 0)
{
data = (PersonData*)peopleList.RemoveItem(--count);
free(data->email);
free(data->group);
delete data;
}
}
BMenuField *field = new BMenuField(menuRect,"ToMenu","",toMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
rect = menuRect;
rect.OffsetBy(0,28);
rect.left = Bounds().left + 5;
rect.right = rect.left + 16;
rect.top += 26;
rect.bottom = rect.top + 16;
ArrowButton *arrow = new ArrowButton(rect,"addr_arrow"
,new BMessage(M_EXPAND_ADDRESS));
AddChild(arrow);
//==================== From menu
BMenu *fromMenu = new BMenu(_("From:"));
BPath path;
::find_directory(B_USER_SETTINGS_DIRECTORY,&path);
path.Append(APP_NAME);
path.Append("Accounts");
BDirectory dir(path.Path());
BEntry entry;
status_t err = B_OK;
int32 account_count = 0;
while(err == B_OK)
{
if((err = dir.GetNextEntry(&entry)) == B_OK && !entry.IsDirectory())
{
char name[B_FILE_NAME_LENGTH+1];
entry.GetName(name);
BMessage *msg = new BMessage(M_ACCOUNT_CHANGE);
msg->AddString("name",name);
BMenuItem *item = new BMenuItem(name,msg);
fromMenu->AddItem(item);
item->SetTarget(this,Window());
account_count++;
}
}
if(account_count != 0)
{
int32 smtp_account;
((HApp*)be_app)->Prefs()->GetData("smtp_account",&smtp_account);
BMenuItem *item(NULL);
if(account_count > smtp_account)
item = fromMenu->ItemAt(smtp_account);
if(!item)
item = fromMenu->ItemAt(0);
if(item)
{
ChangeAccount(item->Label());
item->SetMarked(true);
}
}else{
(new BAlert("",_("Could not find mail accounts"),_("OK"),NULL,NULL,B_WIDTH_AS_USUAL,B_INFO_ALERT))->Go();
Window()->PostMessage(B_QUIT_REQUESTED);
}
fromMenu->SetRadioMode(true);
menuRect.OffsetBy(0,25*2);
field = new BMenuField(menuRect,"FromMenu","",fromMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
AddChild(field);
//=================== CC menu
menuRect.OffsetBy(0,25);
field = new BMenuField(menuRect,"CcMenu","",ccMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
//=================== BCC menu
menuRect.OffsetBy(0,25);
field = new BMenuField(menuRect,"BccMenu","",bccMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
}
/**
* _ConstructGUI()
*
* Creates the GUI for the View. MUST be called AFTER the View is attached to
* the Window, or will crash and/or create strange behaviour
*
* @param none
* @return void
*/
void
MarginView::_ConstructGUI()
{
BString str;
// Create text fields
BRect r(Frame().Width() - be_plain_font->StringWidth("Top#") - kWidth,
kOffsetY, Frame().Width() - kOffsetX, kWidth);
// top
str << fMargins.top/fUnitValue;
fTop = new BTextControl( r, "top", "Top:", str.String(), NULL,
B_FOLLOW_RIGHT);
fTop->SetModificationMessage(new BMessage(TOP_MARGIN_CHANGED));
fTop->SetDivider(be_plain_font->StringWidth("Top#"));
fTop->SetTarget(this);
_AllowOnlyNumbers(fTop, kNumCount);
AddChild(fTop);
//left
r.OffsetBy(0, kOffsetY);
r.left = Frame().Width() - be_plain_font->StringWidth("Left#") - kWidth;
str = "";
str << fMargins.left/fUnitValue;
fLeft = new BTextControl( r, "left", "Left:", str.String(), NULL,
B_FOLLOW_RIGHT);
fLeft->SetModificationMessage(new BMessage(LEFT_MARGIN_CHANGED));
fLeft->SetDivider(be_plain_font->StringWidth("Left#"));
fLeft->SetTarget(this);
_AllowOnlyNumbers(fLeft, kNumCount);
AddChild(fLeft);
//bottom
r.OffsetBy(0, kOffsetY);
r.left = Frame().Width() - be_plain_font->StringWidth("Bottom#") - kWidth;
str = "";
str << fMargins.bottom/fUnitValue;
fBottom = new BTextControl( r, "bottom", "Bottom:", str.String(), NULL,
B_FOLLOW_RIGHT);
fBottom->SetModificationMessage(new BMessage(BOTTOM_MARGIN_CHANGED));
fBottom->SetDivider(be_plain_font->StringWidth("Bottom#"));
fBottom->SetTarget(this);
_AllowOnlyNumbers(fBottom, kNumCount);
AddChild(fBottom);
//right
r.OffsetBy(0, kOffsetY);
r.left = Frame().Width() - be_plain_font->StringWidth("Right#") - kWidth;
str = "";
str << fMargins.right/fUnitValue;
fRight = new BTextControl( r, "right", "Right:", str.String(), NULL,
B_FOLLOW_RIGHT);
fRight->SetModificationMessage(new BMessage(RIGHT_MARGIN_CHANGED));
fRight->SetDivider(be_plain_font->StringWidth("Right#"));
fRight->SetTarget(this);
_AllowOnlyNumbers(fRight, kNumCount);
AddChild(fRight);
// Create Units popup
r.OffsetBy(-kOffsetX, kOffsetY);
r.right += kOffsetY;
BPopUpMenu *menu = new BPopUpMenu("units");
BMenuField *mf = new BMenuField(r, "units", "Units", menu,
B_FOLLOW_BOTTOM | B_FOLLOW_RIGHT);
mf->ResizeToPreferred();
mf->SetDivider(be_plain_font->StringWidth("Units#"));
BMenuItem *item;
// Construct menu items
for (int32 i = 0; kUnitNames[i] != NULL; i++) {
BMessage *msg = new BMessage(MARGIN_UNIT_CHANGED);
msg->AddInt32("marginUnit", kUnitMsg[i]);
menu->AddItem(item = new BMenuItem(kUnitNames[i], msg));
item->SetTarget(this);
if (fMarginUnit == kUnitMsg[i])
item->SetMarked(true);
}
AddChild(mf);
// calculate the sizes for drawing page view
_CalculateViewSize(MARGIN_CHANGED);
}
CDRWView::CDRWView(BRect size)
:
BView(size, "CDRWView", B_FOLLOW_NONE, B_WILL_DRAW)
{
BRect r;
char temp_char[100];
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
// CDRW BOX
IconLabel* CDRWLabel = new IconLabel(BRect(0, 0, 19 + be_bold_font->StringWidth(""), 19), "", "cd_16.png");
CDRWLabel->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
CDRWLabel->SetDrawingMode(B_OP_ALPHA);
r = Bounds();
r.InsetBy(5.0, 5.0);
r.bottom = r.top + 160;
BBox* CDRWBox = new BBox(r, "CDRWBox", B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS, B_PLAIN_BORDER);
CDRWBox->SetLabel(CDRWLabel);
AddChild(CDRWBox);
// BlankMenu (CDRWBOX)
r = CDRWBox->Bounds();
r.InsetBy(5.0, 5.0);
r.top += 25;
fBlankMenu = new BMenu("Select");
fBlankMenu->SetLabelFromMarked(true);
BMenuField* blankMenuField = new BMenuField(r, "blank", "Blank:", fBlankMenu);
blankMenuField->SetDivider(be_plain_font->StringWidth("Blank: "));
CDRWBox->AddChild(blankMenuField);
fBlankMenu->AddItem(new BMenuItem("Full", new BMessage(BLANK_FULL)));
fBlankMenu->AddItem(new BMenuItem("Fast", new BMessage(BLANK_FAST)));
fBlankMenu->AddItem(new BMenuItem("Session", new BMessage(BLANK_SESSION)));
fBlankMenu->AddItem(new BMenuItem("Track", new BMessage(BLANK_TRACK)));
fBlankMenu->AddItem(new BMenuItem("Track tail", new BMessage(BLANK_TRACK_TAIL)));
fBlankMenu->AddItem(new BMenuItem("Unreserve", new BMessage(BLANK_UNRES)));
fBlankMenu->AddItem(new BMenuItem("Unclose", new BMessage(BLANK_UNCLOSE)));
r = CDRWBox->Bounds();
r.left = 150;
r.right = 278;
r.top = 60;
r.bottom = 128;
IconLabel* BGLabel1 = new IconLabel(r, "", "cdrw_64.png"); //cdrw_64.png
BGLabel1->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
BGLabel1->SetDrawingMode(B_OP_BLEND);
CDRWBox->AddChild(BGLabel1);
IconLabel* BGLabel2 = new IconLabel(r, "", "erase_64.png"); //erase_64.png
BGLabel2->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
BGLabel2->SetDrawingMode(B_OP_BLEND);
CDRWBox->AddChild(BGLabel2);
// BlankSpeed
r = CDRWBox->Bounds();
r.InsetBy(5.0, 5.0);
r.top += 15;
r.left = 155;
r.right = 270;
sprintf(temp_char,"Blank Speed [%dx]", BLANK_SPD);
fBlankSpeedSlider = new BSlider(r, "BlankSpeed", temp_char, new BMessage(BLANK_SPEED_CHANGE), 0, 5, B_BLOCK_THUMB, B_FOLLOW_NONE);
fBlankSpeedSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fBlankSpeedSlider->SetHashMarkCount(6);
fBlankSpeedSlider->SetValue((int32)(BLANK_SPD / 2) - 1);
CDRWBox->AddChild(fBlankSpeedSlider);
// BlankButton
r = CDRWBox->Bounds();
r.InsetBy(5.0, 5.0);
r.top += 10;
r.bottom = r.top + 50;
r.left = 330;
r.right = 415;
fBlankButton = new BButton(r, "BlankButton", "Blank!", new BMessage(BLANK_IT_NOW));
CDRWBox->AddChild(fBlankButton);
}
void CPrefsDialog::PostInit()
{
BAutolock lock(this);
strcpy(fNewFontFamily, gPrefs->GetPrefString("defdoc font family", NULL));
fNewFontSize = gPrefs->GetPrefDouble("defdoc font size", 0.0);
strcpy(fNewBFontFamily, gPrefs->GetPrefString("border font family", NULL));
fNewBFontSize = gPrefs->GetPrefDouble("border font size", 0.0);
CellStyle cs;
font_style style;
fOwner->GetCellView()->GetContainer()->GetDefaultCellStyle(cs);
try {
gFontSizeTable.GetFontInfo(cs.fFont, &fDocFontFamily, &style, &fDocFontSize);
gFontSizeTable.GetFontInfo(fOwner->GetCellView()->BorderFontID(),
&fDocBFontFamily, &style, &fDocBFontSize);
}
catch (CErr& e) {
e.DoError();
}
BMenuField *mf = dynamic_cast<BMenuField*>(FindView("docfont"));
fDocFont = mf->Menu();
if (fDocFont)
{
for (long i = 0; i < count_font_families(); i++)
{
font_family ff;
get_font_family(i, &ff);
fDocFont->AddItem(new BMenuItem(ff, new BMessage(msg_Changed)));
}
fDocFont->SetRadioMode(TRUE);
}
mf = dynamic_cast<BMenuField*>(FindView("borderfont"));
fBorderFont = mf->Menu();
for (long i = 0; i < count_font_families(); i++)
{
font_family ff;
get_font_family(i, &ff);
fBorderFont->AddItem(new BMenuItem(ff, new BMessage(msg_Changed)));
}
fBorderFont->SetRadioMode(TRUE);
mf = dynamic_cast<BMenuField*>(FindView("dateorder"));
fDMY = mf->Menu();
fDMY->AddItem(new BMenuItem("dmy", new BMessage(msg_Changed)));
fDMY->AddItem(new BMenuItem("dym", new BMessage(msg_Changed)));
fDMY->AddItem(new BMenuItem("mdy", new BMessage(msg_Changed)));
fDMY->AddItem(new BMenuItem("myd", new BMessage(msg_Changed)));
fDMY->AddItem(new BMenuItem("ydm", new BMessage(msg_Changed)));
fDMY->AddItem(new BMenuItem("ymd", new BMessage(msg_Changed)));
mf = dynamic_cast<BMenuField*>(FindView("neworcur"));
if (mf)
{
fNewOrCur = mf->Menu();
fNewOrCur->AddItem(new BMenuItem("New Documents", new BMessage(msg_ChangeTarget)));
if (fOwner)
{
char s[32];
fDocFont->FindItem(fDocFontFamily)->SetMarked(true);
ftoa(fDocFontSize, s);
SetText("docsize", s);
fBorderFont->FindItem(fDocBFontFamily)->SetMarked(true);
ftoa(fDocBFontSize, s);
SetText("bordersize", s);
fNewOrCur->AddItem(new BMenuItem(fOwner->Title(), new BMessage(msg_ChangeTarget)));
fNewOrCur->ItemAt(1)->SetMarked(true);
}
else
fNewOrCur->ItemAt(0)->SetMarked(true);
mf->SetDivider(be_plain_font->StringWidth(mf->Label()) + 4);
}
BBox *b;
BView *v;
v = FindView("prgrid");
b = dynamic_cast<BBox*>(v->Parent());
if (b)
{
char t[256];
sprintf(t, b->Label(), fOwner->Title());
b->SetLabel(t);
}
fAutoRecalc = fOwner->GetCellView()->DoesAutoRecalc();
fDisplayZero = fOwner->GetCellView()->DoesDisplayZero();
fPrGrid = fOwner->GetCellView()->PrintsGrid();
fPrBorders = fOwner->GetCellView()->PrintsBorders();
fShGrid = fOwner->GetCellView()->ShowsGrid();
fShBorders = fOwner->GetCellView()->ShowsBorders();
CancelClicked();
Show();
} /* CPrefsDialog::PostInit */
BView *PrefsWindow::create_graphics_pane(void)
{
BView *pane = new BView(BRect(0, 0, top_frame.right-20, top_frame.bottom-80), GetString(STR_GRAPHICS_SOUND_PANE_TITLE), B_FOLLOW_NONE, B_WILL_DRAW);
pane->SetViewColor(fill_color);
float right = pane->Bounds().right-10;
const char *mode_str = PrefsFindString("screen");
int width = 512, height = 384;
scr_mode_bit = 0;
display_type = DISPLAY_WINDOW;
if (mode_str) {
if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2)
display_type = DISPLAY_WINDOW;
else if (sscanf(mode_str, "scr/%d", &scr_mode_bit) == 1)
display_type = DISPLAY_SCREEN;
}
BMenuField *menu_field;
BMenuItem *item;
BPopUpMenu *menu;
menu = new BPopUpMenu("");
menu_field = new BMenuField(BRect(10, 5, right, 20), "videotype", GetString(STR_VIDEO_TYPE_CTRL), menu);
menu_field->SetDivider(120);
menu->AddItem(item = new BMenuItem(GetString(STR_WINDOW_LAB), new BMessage(MSG_VIDEO_WINDOW)));
if (display_type == DISPLAY_WINDOW)
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(GetString(STR_FULLSCREEN_LAB), new BMessage(MSG_VIDEO_SCREEN)));
if (display_type == DISPLAY_SCREEN)
item->SetMarked(true);
pane->AddChild(menu_field);
menu = new BPopUpMenu("");
frameskip_menu = new BMenuField(BRect(10, 26, right, 41), "frameskip", GetString(STR_FRAMESKIP_CTRL), menu);
frameskip_menu->SetDivider(120);
menu->AddItem(new BMenuItem(GetString(STR_REF_5HZ_LAB), new BMessage(MSG_REF_5HZ)));
menu->AddItem(new BMenuItem(GetString(STR_REF_7_5HZ_LAB), new BMessage(MSG_REF_7_5HZ)));
menu->AddItem(new BMenuItem(GetString(STR_REF_10HZ_LAB), new BMessage(MSG_REF_10HZ)));
menu->AddItem(new BMenuItem(GetString(STR_REF_15HZ_LAB), new BMessage(MSG_REF_15HZ)));
menu->AddItem(new BMenuItem(GetString(STR_REF_30HZ_LAB), new BMessage(MSG_REF_30HZ)));
pane->AddChild(frameskip_menu);
int32 i32 = PrefsFindInt32("frameskip");
if (i32 == 12) {
if ((item = menu->FindItem(GetString(STR_REF_5HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (i32 == 8) {
if ((item = menu->FindItem(GetString(STR_REF_7_5HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (i32 == 6) {
if ((item = menu->FindItem(GetString(STR_REF_10HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (i32 == 4) {
if ((item = menu->FindItem(GetString(STR_REF_15HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (i32 == 2) {
if ((item = menu->FindItem(GetString(STR_REF_30HZ_LAB))) != NULL)
item->SetMarked(true);
}
display_x_ctrl = new NumberControl(BRect(10, 48, right / 2, 66), 118, "width", GetString(STR_DISPLAY_X_CTRL), width, NULL);
pane->AddChild(display_x_ctrl);
display_y_ctrl = new NumberControl(BRect(10, 69, right / 2, 87), 118, "height", GetString(STR_DISPLAY_Y_CTRL), height, NULL);
pane->AddChild(display_y_ctrl);
menu = new BPopUpMenu("");
scr_mode_menu = new BMenuField(BRect(10, 26, right, 41), "screenmode", GetString(STR_SCREEN_MODE_CTRL), menu);
scr_mode_menu->SetDivider(120);
for (int i=0; scr_mode[i].mode_mask; i++) {
menu->AddItem(item = new BMenuItem(GetString(scr_mode[i].str), new BMessage(MSG_SCREEN_MODE + i)));
if (scr_mode[i].mode_mask & (1 << scr_mode_bit))
item->SetMarked(true);
}
pane->AddChild(scr_mode_menu);
nosound_checkbox = new BCheckBox(BRect(10, 90, right, 105), "nosound", GetString(STR_NOSOUND_CTRL), new BMessage(MSG_NOSOUND));
pane->AddChild(nosound_checkbox);
nosound_checkbox->SetValue(PrefsFindBool("nosound") ? B_CONTROL_ON : B_CONTROL_OFF);
hide_show_graphics_ctrls();
return pane;
}
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);
}
void
DocInfoWindow::_SetupDocInfoView(BBox* panel)
{
BRect bounds(panel->Bounds());
#if HAVE_FULLVERSION_PDF_LIB
bounds.InsetBy(10.0, 10.0);
#endif
// add list of keys
fKeyList = new BMenu("Delete Key");
BMenuField *menu = new BMenuField(bounds, "delete", "", fKeyList,
B_FOLLOW_BOTTOM);
panel->AddChild(menu);
menu->SetDivider(0);
#ifdef __HAIKU__
menu->ResizeToPreferred();
menu->MoveTo(bounds.left, bounds.bottom - menu->Bounds().Height());
#else
menu->ResizeTo(menu->StringWidth("Delete Key") + 15.0, 25.0);
menu->MoveTo(bounds.left, bounds.bottom - 25.0);
#endif
const char* title[6] = { "Title", "Author", "Subject", "Keywords", "Creator",
NULL }; // PDFlib sets these: "Producer", "CreationDate", not "ModDate"
BMenu* defaultKeys = new BMenu("Default Keys");
for (int32 i = 0; title[i] != NULL; ++i)
defaultKeys->AddItem(new BMenuItem(title[i], new BMessage(DEFAULT_KEY_MSG)));
BRect frame(menu->Frame());
menu = new BMenuField(frame, "add", "", defaultKeys, B_FOLLOW_BOTTOM);
panel->AddChild(menu);
menu->SetDivider(0);
#ifdef __HAIKU__
menu->ResizeToPreferred();
menu->MoveBy(frame.Width() + 10.0, 0.0);
#else
menu->ResizeTo(menu->StringWidth("Default Keys") + 15.0, 25.0);
menu->MoveBy(menu->Bounds().Width() + 10.0, 0.0);
#endif
frame = menu->Frame();
frame.left = frame.right + 10.0;
frame.right = bounds.right;
BTextControl *add = new BTextControl(frame, "add", "Add Key:", "",
new BMessage(ADD_KEY_MSG), B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM);
panel->AddChild(add);
float width, height;
add->GetPreferredSize(&width, &height);
add->ResizeTo(bounds.right - frame.left, height);
add->SetDivider(be_plain_font->StringWidth("Add Key: "));
bounds.bottom = frame.top - 10.0;
bounds.right -= B_V_SCROLL_BAR_WIDTH;
bounds.InsetBy(2.0, 2.0);
fTable = new BView(bounds, "table", B_FOLLOW_ALL, B_WILL_DRAW);
fTable->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fTableScrollView = new BScrollView("scroll_table", fTable, B_FOLLOW_ALL, 0,
false, true);
panel->AddChild(fTableScrollView);
BMessage docInfo;
fDocInfo->FindMessage("doc_info", &docInfo);
// fill table
_BuildTable(docInfo);
}
FindWindow::FindWindow(BRect _rect, BMessage& previous, BMessenger& target,
const BMessage* settings)
: BWindow(_rect, B_TRANSLATE("Find"), B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_CLOSE_ON_ESCAPE),
fTarget(target)
{
BView* view = new BView(Bounds(), "main", B_FOLLOW_ALL, 0);
view->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
AddChild(view);
int8 mode = kAsciiMode;
if (previous.FindInt8("find_mode", &mode) != B_OK && settings != NULL)
settings->FindInt8("find_mode", &mode);
// add the top widgets
fMenu = new BPopUpMenu("mode");
BMessage* message;
BMenuItem* item;
fMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Text"),
message = new BMessage(kMsgFindMode)));
message->AddInt8("mode", kAsciiMode);
if (mode == kAsciiMode)
item->SetMarked(true);
fMenu->AddItem(item = new BMenuItem(B_TRANSLATE_COMMENT("Hexadecimal",
"A menu item, as short as possible, noun is recommended if it is "
"shorter than adjective."), message = new BMessage(kMsgFindMode)));
message->AddInt8("mode", kHexMode);
if (mode == kHexMode)
item->SetMarked(true);
BRect rect = Bounds().InsetByCopy(5, 5);
BMenuField* menuField = new BMenuField(rect, B_EMPTY_STRING,
B_TRANSLATE("Mode:"), fMenu, B_FOLLOW_LEFT | B_FOLLOW_TOP);
menuField->SetDivider(menuField->StringWidth(menuField->Label()) + 8);
menuField->ResizeToPreferred();
view->AddChild(menuField);
// add the bottom widgets
BButton* button = new BButton(rect, B_EMPTY_STRING, B_TRANSLATE("Find"),
new BMessage(kMsgStartFind), B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM);
button->MakeDefault(true);
button->ResizeToPreferred();
button->MoveTo(rect.right - button->Bounds().Width(),
rect.bottom - button->Bounds().Height());
view->AddChild(button);
fCaseCheckBox = new BCheckBox(rect, B_EMPTY_STRING, B_TRANSLATE("Case sensitive"),
NULL, B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
fCaseCheckBox->ResizeToPreferred();
fCaseCheckBox->MoveTo(5, button->Frame().top);
bool caseSensitive;
if (previous.FindBool("case_sensitive", &caseSensitive) != B_OK) {
if (settings == NULL
|| settings->FindBool("case_sensitive", &caseSensitive) != B_OK)
caseSensitive = true;
}
fCaseCheckBox->SetValue(caseSensitive);
view->AddChild(fCaseCheckBox);
// and now those inbetween
rect.top = menuField->Frame().bottom + 5;
rect.bottom = fCaseCheckBox->Frame().top - 8;
rect.InsetBy(2, 2);
fTextView = new FindTextView(rect, B_EMPTY_STRING,
rect.OffsetToCopy(B_ORIGIN).InsetByCopy(3, 3), B_FOLLOW_ALL);
fTextView->SetWordWrap(true);
fTextView->SetMode((find_mode)mode);
fTextView->SetData(previous);
BScrollView* scrollView = new BScrollView("scroller", fTextView,
B_FOLLOW_ALL, B_WILL_DRAW, false, false);
view->AddChild(scrollView);
ResizeTo(290, button->Frame().Height() * 3 + 30);
SetSizeLimits(fCaseCheckBox->Bounds().Width() + button->Bounds().Width()
+ 20, 32768, button->Frame().Height() * 3 + 10, 32768);
}
CatBrowser::CatBrowser(const BRect &frame, const BMessenger &msgr,
const char *category, bool editmode)
: BWindow(frame,"Recipe Browser",B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS),
fMessenger(msgr),
fCategoryCount(-1),
fCurrentPage(-1),
fEditMode(editmode)
{
AddShortcut('W', B_COMMAND_KEY, new BMessage(B_QUIT_REQUESTED));
AddShortcut('Q', B_COMMAND_KEY, new BMessage(M_QUIT_APP));
BView *back = new BView(Bounds(),"back",B_FOLLOW_ALL, B_WILL_DRAW);
back->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
AddChild(back);
fCategories = new BMenu("Categories");
CppSQLite3Query query = DBQuery("select category from categories order by category;",
"FindWindow:get categories");
while(!query.eof())
{
BString cat(DeescapeIllegalCharacters(query.getStringField(0)));
fCategories->AddItem(new BMenuItem(cat.String(),new BMessage(M_SET_CATEGORY)));
query.nextRow();
}
fCategories->SetRadioMode(true);
fCategories->SetLabelFromMarked(true);
if(fCategories->CountItems()>0)
fCategories->ItemAt(0)->SetMarked(true);
BRect r(10,10,10 + fCategories->MaxContentWidth(),11);
BMenuField *field = new BMenuField(r,"field","Category",fCategories);
back->AddChild(field);
field->ResizeToPreferred();
r = field->Frame();
BMenuItem *marked = fCategories->FindItem(category);
if(marked)
marked->SetMarked(true);
r.OffsetBy(0,r.Height() + 10);
r.right = Bounds().right - 10 - B_V_SCROLL_BAR_WIDTH;
r.bottom = Bounds().bottom - 10;
fList = new BListView(r, "newlist", B_SINGLE_SELECTION_LIST, B_FOLLOW_ALL);
fList->SetInvocationMessage(new BMessage(M_SET_RECIPE));
BScrollView *newscroll = new BScrollView("newscroll",fList,
B_FOLLOW_ALL, 0, false, true);
back->AddChild(newscroll);
fBack = new BButton(BRect(10,10,11,11),"back","Back", new BMessage(M_RESULTS_BACK),
B_FOLLOW_LEFT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
fBack->ResizeToPreferred();
fBack->ResizeTo(be_plain_font->StringWidth("Back") + 15,fBack->Frame().Height());
fBack->MoveTo(10,Bounds().bottom - fBack->Bounds().Height() - 10);
r = fBack->Frame();
back->AddChild(fBack);
fBack->SetEnabled(false);
r.OffsetBy(r.Width() + 5, 0);
fNext = new BButton(r,"next","Next", new BMessage(M_RESULTS_NEXT),
B_FOLLOW_LEFT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
back->AddChild(fNext);
fNext->SetEnabled(false);
fClose = new BButton(BRect(10,10,11,11),"close","View Recipe", new BMessage(B_QUIT_REQUESTED),
B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
fClose->ResizeToPreferred();
fClose->SetLabel("Close");
fClose->MoveTo(Bounds().right - fClose->Bounds().Width() - 10,r.top);
r = fClose->Frame();
fClose->MakeDefault(true);
r.OffsetBy(-r.Width() - 10, 0);
fOpen = new BButton(r,"openrecipe","View Recipe",new BMessage(M_SET_RECIPE),
B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, B_WILL_DRAW);
back->AddChild(fOpen);
back->AddChild(fClose);
fList->MakeFocus(true);
r = fList->Parent()->Frame();
r.bottom = fClose->Frame().top - 10;
fList->Parent()->ResizeTo(r.Width(),r.Height());
float controlwidth = (fBack->Frame().Width() * 2) + (fOpen->Frame().Width() * 2) + 65;
if( Frame().Width() < controlwidth )
ResizeTo(controlwidth, Frame().Height());
if(fEditMode)
{
// This hidden mode (Command-Click on the browser menu item) is for doing
// massive edits on the database
fList->SetListType(B_MULTIPLE_SELECTION_LIST);
fList->SetSelectionMessage(new BMessage(M_SET_RECIPE));
BMenu *editmenu = new BMenu("Edit");
editmenu->AddItem(new BMenuItem("Mass Recategorize",new BMessage(M_SHOW_RECAT)));
editmenu->AddItem(new BMenuItem("Delete Recipe",new BMessage(M_DELETE_RECIPE)));
r.Set(10,10,10 + be_plain_font->StringWidth("Edit") + 25,11);
r.OffsetTo(Bounds().right - 10 - r.Width(), 10);
BMenuField *editfield = new BMenuField(r,"editfield","Edit",editmenu,
B_FOLLOW_RIGHT | B_FOLLOW_TOP);
editfield->SetDivider(0);
back->AddChild(editfield);
fSortString = " order by number ";
}
PostMessage(M_SET_CATEGORY);
}
void SketchApp::ReadyToRun()
{
// Build a menu into your filepanel for fun and profit!
SketchWindow *mainWindow = ((SketchWindow *)FindWindow("Etch-A-Sketch"B_UTF8_REGISTERED));
//BFilePanel *saver = NULL;
BMenuField *formatMenu = NULL;
BMenu *menu = NULL;
BView *saverView = NULL;
BRect rect, bounds;
menu_info m_info;
int32 menubarheight=0;
// get some menu measurements
get_menu_info(&m_info);
menubarheight = (int32)m_info.font_size + 8;
// make the filepanel
saver = new BFilePanel(B_SAVE_PANEL, NULL, NULL, B_FILE_NODE, false); // _ctor
if(saver->Window()->Lock())
{
// get a pointer to a view
saverView = (BView *)saver->Window()->ChildAt(0);
// get a rect for the filepanel's window
bounds = saverView->Bounds();
// make a menu
menu = new BMenu("Format");
// construct the BMenuFeild for the menu
rect.Set(bounds.right - 100, bounds.top + menubarheight, bounds.right - 40, bounds.top + menubarheight + 15);
formatMenu = new BMenuField(rect, "format menu", "", menu);
formatMenu->SetDivider(0);
// Below was ganked from the BeBook
//find all the translators
BTranslatorRoster *roster = BTranslatorRoster::Default();
int32 num_translators, i;
translator_id *translators;
const char *translator_name, *translator_info;
int32 translator_version;
roster->GetAllTranslators(&translators, &num_translators); // function allocates the memory for translators
for (i=0;i<num_translators;i++)
{
const translation_format *fmts;
int32 num_fmts;
roster->GetTranslatorInfo(translators[i], &translator_name, &translator_info, &translator_version);
roster->GetOutputFormats(translators[i], &fmts, &num_fmts);
if(fmts[0].group == B_TRANSLATOR_BITMAP) // make sure we only get bitmap translators
{
BMessage *message = new BMessage(TRANSLATOR);
message->AddString("save format", fmts[0].MIME);
if(i == 0)
mainWindow->PostMessage(message); // this will init 'format' for us
menu->AddItem(new BMenuItem(translator_name, message));
}
//printf("%s: %s (%.2f)\n", translator_name, translator_info, translator_version/100.);
}
delete [] translators; // clean up our droppings
// found em all
menu->SetRadioMode(true);
menu->ItemAt(0)->SetMarked(true);
menu->SetTargetForItems(mainWindow);
saverView->AddChild(formatMenu);
saver->Window()->Unlock();
}
}
BView* SeqPrefWin::NewFileView(BRect bounds, const BMessage& prefs) const
{
BView* v = new BView( bounds, FILE_STR, B_FOLLOW_ALL, 0 );
if( !v ) return v;
v->SetViewColor( Prefs().Color(AM_AUX_WINDOW_BG_C) );
float fh = view_font_height(v);
float bfh = bold_font_height();
float openH = bfh + 5 + fh + 5 + fh + 5 + fh;
/* The Remember Open Songs preference.
*/
float w = v->StringWidth("Remember open songs") + 25;
BRect f(bounds.left + 5, bounds.top + 5, bounds.left + 5 + w, bounds.top + 5 + fh);
BCheckBox* cb = new BCheckBox( f, REMEMBER_OPEN_STR, "Remember open songs", new BMessage(REMEMBER_OPEN_MSG) );
if( cb ) {
bool b;
if( prefs.FindBool(REMEBER_OPEN_SONGS_PREF, &b) != B_OK ) b = false;
cb->SetValue( (b) ? B_CONTROL_ON : B_CONTROL_OFF );
v->AddChild( cb );
}
/* The Skin preference.
*/
BMenu* menu = new BMenu("skin_menu");
BMessage skinMsg(CHANGE_SKIN_MSG);
BMenuItem* item = new BMenuItem( "Default", new BMessage(CHANGE_SKIN_TO_DEFAULT_MSG) );
item->SetMarked(true);
menu->AddItem(item);
menu->AddSeparatorItem();
menu->SetLabelFromMarked(true);
if( seq_make_skin_menu(menu, &skinMsg) == B_OK ) {
const char* label = "Choose skin:";
f.Set(f.left, f.bottom + 8, bounds.right - 5, f.bottom + 8 + fh + 10);
BMenuField* field = new BMenuField(f, "skin_field", label, menu);
if (field) {
field->SetDivider( v->StringWidth(label) + 10 );
v->AddChild(field);
} else delete menu;
} else delete menu;
/* The Open New Songs preferences.
*/
f.Set(bounds.left + 5, f.bottom + 10, bounds.right - 5, f.bottom + 10 + openH + 10);
BBox* box = new BBox( f,
"open_new_songs",
B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
if( box ) {
box->SetLabel( "Open New Songs" );
BRect boxB = box->Bounds();
BRect sf(boxB.left + 5, boxB.top + 5 + bfh, boxB.right - 5, boxB.top + 5 + bfh + fh);
const char* choice;
if( prefs.FindString(OPEN_NEW_SONG_PREF, &choice) != B_OK ) choice = 0;
BRadioButton* button = new BRadioButton( sf, OPEN_BLANK_STR, "Blank", new BMessage(OPEN_BLANK_MSG), B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP );
if( button ) {
if( choice && strcmp(choice, "blank") == 0 ) button->SetValue( B_CONTROL_ON );
box->AddChild( button );
}
sf.OffsetBy( 0, 5 + fh );
button = new BRadioButton( sf, OPEN_FOUR_STR, "With two channels of each device", new BMessage(OPEN_FOUR_MSG), B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP );
if( button ) {
if( choice && strcmp(choice, "channels") == 0 ) button->SetValue( B_CONTROL_ON );
box->AddChild( button );
}
sf.OffsetBy( 0, 5 + fh );
button = new BRadioButton( sf, OPEN_FILE_STR, "From file: <click to select>", new BMessage(OPEN_FILE_MSG), B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP );
if( button ) {
if( choice && strcmp(choice, "file") == 0 ) button->SetValue( B_CONTROL_ON );
entry_ref ref;
if( prefs.FindRef(OPEN_NEW_SONG_FILE_PREF, &ref) == B_OK )
button->SetLabel( label_for_open_new_from_file(&ref).String() );
box->AddChild( button );
}
v->AddChild( box );
f.OffsetBy(0, f.bottom - f.top + 10 );
}
/* The Open From Query preferences
*/
f.bottom = bounds.bottom - 27;
box = new BBox( f, "open_from_query", B_FOLLOW_ALL);
if( box ) {
box->SetLabel("Open From Query");
BRect boxB = box->Bounds();
BRect tableF(boxB.left + 5, boxB.top + 5 + bfh, boxB.right - 5, boxB.bottom - 35);
mOwqTable = new _OwqList( tableF, mPreferences );
if( mOwqTable ) {
mOwqTable->SetLatchWidth( 0 );
box->AddChild( mOwqTable );
mOwqTable->AddColumn( new BStringColumn(ON_STR, 40, 20, 100, B_TRUNCATE_END), 0 );
mOwqTable->AddColumn( new BStringColumn(NAME_STR, 100, 20, 150, B_TRUNCATE_END), 1 );
mOwqTable->AddColumn( new BStringColumn(QUERY_STR, 180, 20, 450, B_TRUNCATE_MIDDLE), 2 );
// mOwqTable->AddColumn( new BStringColumn(SKIP_TOP_LEVEL_STR, 100, 20, 250, B_TRUNCATE_END), 3 );
mOwqTable->SetSortColumn(mOwqTable->ColumnAt(1), false, true);
// mOwqTable->SetSortColumn(mOwqTable->ColumnAt(), true, true);
mOwqTable->SetSelectionMode( B_SINGLE_SELECTION_LIST );
BRect bF(tableF.left, tableF.bottom + 5, tableF.left + 55, tableF.Height() - 10);
BButton* add = new BButton( bF, "owq_add", "Add", new BMessage(OWQ_INVOKE_ADD), B_FOLLOW_LEFT | B_FOLLOW_BOTTOM );
if( add ) box->AddChild( add );
bF.OffsetBy( bF.Width() + 5, 0 );
BButton* change = new BButton( bF, "owq_change", "Change", new BMessage(OWQ_CHANGE), B_FOLLOW_LEFT | B_FOLLOW_BOTTOM );
if( change ) {
change->SetEnabled( false );
box->AddChild( change );
}
bF.OffsetBy( bF.Width() + 5, 0 );
BButton* remove = new BButton( bF, "owq_remove", "Remove", new BMessage(OWQ_REMOVE), B_FOLLOW_LEFT | B_FOLLOW_BOTTOM );
if( remove ) {
remove->SetEnabled( false );
box->AddChild( remove );
}
mOwqTable->SetButtons( add, change, remove );
}
v->AddChild( box );
}
return v;
}
tabTowar::tabTowar(BTabView *tv, sqlite *db, BHandler *hr) : beFakTab(tv, db, hr) {
curdata = new towardat(db);
this->dirty = false;
this->tab->SetLabel("Towary [F3]");
BRect r;
r = this->view->Bounds();
// columnlistview
r.left = 5; r.right = 160; r.top = 30; r.bottom = 490;
CLVContainerView *containerView;
list = new ColumnListView(r, &containerView, NULL, B_FOLLOW_LEFT|B_FOLLOW_TOP_BOTTOM,
B_WILL_DRAW|B_FRAME_EVENTS|B_NAVIGABLE, B_SINGLE_SELECTION_LIST, false, true, true, true,
B_FANCY_BORDER);
list->AddColumn(new CLVColumn("Symbol", 54, CLV_TELL_ITEMS_WIDTH|CLV_HEADER_TRUNCATE|CLV_SORT_KEYABLE));
list->AddColumn(new CLVColumn("Nazwa", 100, CLV_TELL_ITEMS_WIDTH|CLV_HEADER_TRUNCATE|CLV_SORT_KEYABLE));
list->SetSortFunction(CLVEasyItem::CompareItems);
this->view->AddChild(containerView);
list->SetInvocationMessage(new BMessage(LIST_INV));
list->SetSelectionMessage(new BMessage(LIST_SEL));
// buttons
but_new = new BButton(BRect(30,0,140,24), "tt_but_new", "Nowy towar [F5]", new BMessage(BUT_NEW), B_FOLLOW_LEFT|B_FOLLOW_TOP);
but_del = new BButton(BRect(30,510,140,534), "tt_but_del", "Usuń zaznaczone [F8]", new BMessage(BUT_DEL), B_FOLLOW_LEFT|B_FOLLOW_BOTTOM);
but_restore = new BButton(BRect(235,510,325,534), "tt_but_restore", "Przywróć [F6]", new BMessage(BUT_RESTORE), B_FOLLOW_LEFT|B_FOLLOW_BOTTOM);
but_save = new BButton(BRect(580,510,670,534), "tt_but_save", "Zapisz", new BMessage(BUT_SAVE), B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
this->view->AddChild(but_new);
this->view->AddChild(but_del);
this->view->AddChild(but_restore);
this->view->AddChild(but_save);
but_new->ResizeToPreferred();
but_del->ResizeToPreferred();
but_restore->ResizeToPreferred();
but_save->ResizeToPreferred();
// box1
box1 = new BBox(BRect(230,30,710,140), "tt_box1");
box1->SetLabel("Dane towaru");
this->view->AddChild(box1);
// box1-stuff
data[0] = new BTextControl(BRect(10,15,270,35), "ttd0", "Nazwa", NULL, new BMessage(DC));
data[1] = new BTextControl(BRect(280,15,420,35), "ttd1", "Symbol", NULL, new BMessage(DC));
data[2] = new BTextControl(BRect(10,50,150,65), "ttd2", "PKWiU", NULL, new BMessage(DC));
data[3] = new BTextControl(BRect(160,50,270,65), "ttd3", "j.m.", NULL, new BMessage(DC));
box1->AddChild(data[0]); box1->AddChild(data[1]);
box1->AddChild(data[2]); box1->AddChild(data[3]);
usluga = new BCheckBox(BRect(350,50,420,65), "ttdo", "Usługa", new BMessage(DC));
box1->AddChild(usluga);
dodany = new BStringView(BRect(280,80,340,95), "tts0", "Dodano:");
dodany->SetAlignment(B_ALIGN_RIGHT);
box1->AddChild(dodany);
dodany = new BStringView(BRect(350,80,420,95), "ttsd", "");
box1->AddChild(dodany);
// box1-menu
BMenu *menujm = new BMenu("");
BMessage *msg;
int j=0;
while (jmiary[j] != NULL) {
msg = new BMessage(MENUJM); msg->AddString("_jm",jmiary[j]);
menujm->AddItem(new BMenuItem(jmiary[j], msg));
j++;
}
BMenuField *menujmField = new BMenuField(BRect(280,50,340,65), "ttmf", NULL, menujm);
box1->AddChild(menujmField);
// box2
box2 = new BBox(BRect(230,150,710,300), "tt_box2");
box2->SetLabel("Ceny");
this->view->AddChild(box2);
// box2-stuff
ceny[0] = new BTextControl(BRect(10,15,190,35), "ttc0", "Cena netto (zł)", NULL, new BMessage(DC));
ceny[1] = new BTextControl(BRect(10,50,190,65), "ttc1", "Netto zakupu", NULL, new BMessage(DC));
ceny[2] = new BTextControl(BRect(10,80,190,95), "ttc2", "Marża (%)", NULL, new BMessage(DC));
ceny[3] = new BTextControl(BRect(200,50,310,65), "ttc3", "Rabat (%)", NULL, new BMessage(DC));
ceny[4] = new BTextControl(BRect(10,110,190,125), "ttc4", "Kurs waluty", "1", new BMessage(DC));
ceny[5] = new BTextControl(BRect(200,110,310,125), "ttc5", "Cło (%)", NULL, new BMessage(DC));
box2->AddChild(ceny[0]);
box2->AddChild(ceny[1]);
box2->AddChild(ceny[2]);
box2->AddChild(ceny[3]);
box2->AddChild(ceny[4]);
box2->AddChild(ceny[5]);
but_sell = new BButton(BRect(340,50,420,65), "tt_but_sell", "Cena sprzedaży", new BMessage(BUT_SELL));
but_marza = new BButton(BRect(340,80,420,95), "tt_but_marza", "Marża", new BMessage(BUT_MARZA));
but_import = new BButton(BRect(340,110,420,125), "tt_but_import", "Import", new BMessage(BUT_IMPORT));
box2->AddChild(but_sell);
box2->AddChild(but_marza);
box2->AddChild(but_import);
but_sell->ResizeToPreferred();
but_marza->ResizeToPreferred();
but_import->ResizeToPreferred();
brutto = new BStringView(BRect(330,15,390,35), "ttb0", "Cena brutto:");
box2->AddChild(brutto);
brutto = new BStringView(BRect(400,15,475,35), "ttbr", NULL);
box2->AddChild(brutto);
// box2-menu
menuvat = new BPopUpMenu("[wybierz]");
vatRows = 0; vatIds = NULL;
RefreshVatSymbols();
BMenuField *menuvatField = new BMenuField(BRect(200,15,330,35), "ttmv", "VAT", menuvat);
menuvatField->SetDivider(be_plain_font->StringWidth(menuvatField->Label())+15);
box2->AddChild(menuvatField);
// box3
box3 = new BBox(BRect(230,310,710,390), "tt_box3");
box3->SetLabel("Magazyn");
this->view->AddChild(box3);
// box3-stuff
magazyn = new BTextControl(BRect(10,30,250,40), "ttm0", "Stan:", NULL, new BMessage(DC));
magzmiana = new BStringView(BRect(230,30,370,45), "ttm1", "Ostatnia zmiana:");
magzmiana->SetAlignment(B_ALIGN_RIGHT);
box3->AddChild(magzmiana);
magzmiana = new BStringView(BRect(380,35,470,45), "ttm2", NULL);
box3->AddChild(magzmiana);
box3->AddChild(magazyn);
// box4
box4 = new BBox(BRect(230,400,710,480), "tt_box4");
box4->SetLabel("Notatki");
this->view->AddChild(box4);
// box4-stuff
r = box4->Bounds();
r.InsetBy(10,15);
BRect s = r; s.OffsetTo(0,0);
notatki = new BTextView(r, "ttno", s, B_FOLLOW_LEFT|B_FOLLOW_TOP, B_WILL_DRAW);
box4->AddChild(notatki);
// fix widths
int i;
// first set them to be enough
for (i=0;i<=3;i++) {
data[i]->SetDivider(be_plain_font->StringWidth(data[i]->Label())+5);
}
for (i=0;i<=5;i++) {
ceny[i]->SetDivider(be_plain_font->StringWidth(ceny[i]->Label())+5);
}
magazyn->SetDivider(be_plain_font->StringWidth(magazyn->Label())+5);
// align in columns
float d;
d = max(data[0]->Divider(), data[2]->Divider());
data[0]->SetDivider(d); data[2]->SetDivider(d);
d = max(ceny[0]->Divider(), ceny[1]->Divider());
d = max(ceny[2]->Divider(), d);
d = max(ceny[4]->Divider(), d);
ceny[0]->SetDivider(d); ceny[1]->SetDivider(d);
ceny[2]->SetDivider(d); ceny[4]->SetDivider(d);
//
but_save->MakeDefault(true);
updateTab();
RefreshIndexList();
}