/*! Marks the menu items corresponding to the dead key state of the current
key map.
*/
void
KeymapWindow::_UpdateDeadKeyMenu()
{
BString trigger;
fCurrentMap.GetDeadKeyTrigger(kDeadKeyAcute, trigger);
if (!trigger.Length())
trigger = kDeadKeyTriggerNone;
BMenuItem* menuItem = fAcuteMenu->FindItem(trigger.String());
if (menuItem)
menuItem->SetMarked(true);
fCurrentMap.GetDeadKeyTrigger(kDeadKeyCircumflex, trigger);
if (!trigger.Length())
trigger = kDeadKeyTriggerNone;
menuItem = fCircumflexMenu->FindItem(trigger.String());
if (menuItem)
menuItem->SetMarked(true);
fCurrentMap.GetDeadKeyTrigger(kDeadKeyDiaeresis, trigger);
if (!trigger.Length())
trigger = kDeadKeyTriggerNone;
menuItem = fDiaeresisMenu->FindItem(trigger.String());
if (menuItem)
menuItem->SetMarked(true);
fCurrentMap.GetDeadKeyTrigger(kDeadKeyGrave, trigger);
if (!trigger.Length())
trigger = kDeadKeyTriggerNone;
menuItem = fGraveMenu->FindItem(trigger.String());
if (menuItem)
menuItem->SetMarked(true);
fCurrentMap.GetDeadKeyTrigger(kDeadKeyTilde, trigger);
if (!trigger.Length())
trigger = kDeadKeyTriggerNone;
menuItem = fTildeMenu->FindItem(trigger.String());
if (menuItem)
menuItem->SetMarked(true);
}
BPopUpMenu*
TPrefsWindow::_BuildBoolMenu(uint32 what, const char* boolItem, bool isTrue)
{
BMenuItem* item;
BMessage* msg;
BPopUpMenu* menu;
menu = new BPopUpMenu("");
msg = new BMessage(what);
msg->AddBool(boolItem, true);
menu->AddItem(item = new BMenuItem("On", msg));
if (isTrue)
item->SetMarked(true);
msg = new BMessage(what);
msg->AddInt32(boolItem, false);
menu->AddItem(item = new BMenuItem("Off", msg));
if (!isTrue)
item->SetMarked(true);
return menu;
}
// add_menu_item
void
add_menu_item(BMenu* menu,
uint32 compression,
const char* label,
uint32 currentCompression)
{
// COMPRESSION_NONE
BMessage* message = new BMessage(TIFFView::MSG_COMPRESSION_CHANGED);
message->AddInt32("value", compression);
BMenuItem* item = new BMenuItem(label, message);
item->SetMarked(currentCompression == compression);
menu->AddItem(item);
}
BPopUpMenu*
TPrefsWindow::_BuildLevelMenu(int32 level)
{
BMenuItem* item;
BMessage* msg;
BPopUpMenu* menu;
menu = new BPopUpMenu("");
msg = new BMessage(P_LEVEL);
msg->AddInt32("level", L_BEGINNER);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Beginner"), msg));
if (level == L_BEGINNER)
item->SetMarked(true);
msg = new BMessage(P_LEVEL);
msg->AddInt32("level", L_EXPERT);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Expert"), msg));
if (level == L_EXPERT)
item->SetMarked(true);
return menu;
}
status_t
ConfigWindow::_SetToGeneralSettings(BMailSettings *settings)
{
if (!settings)
return B_BAD_VALUE;
status_t status = settings->InitCheck();
if (status != B_OK)
return status;
// retrieval frequency
time_t interval = time_t(settings->AutoCheckInterval() / 1e6L);
char text[25];
text[0] = 0;
int timeIndex = 0;
if (interval >= 60) {
timeIndex = 1;
sprintf(text, "%" B_PRIdTIME, interval / (60));
}
if (interval >= (60*60)) {
timeIndex = 2;
sprintf(text, "%" B_PRIdTIME, interval / (60*60));
}
if (interval >= (60*60*24)) {
timeIndex = 3;
sprintf(text, "%" B_PRIdTIME, interval / (60*60*24));
}
fIntervalControl->SetText(text);
if (BMenuItem *item = fIntervalUnitField->Menu()->ItemAt(timeIndex))
item->SetMarked(true);
fIntervalControl->SetEnabled(timeIndex != 0);
fPPPActiveCheckBox->SetValue(settings->CheckOnlyIfPPPUp());
fPPPActiveSendCheckBox->SetValue(settings->SendOnlyIfPPPUp());
fAutoStartCheckBox->SetValue(settings->DaemonAutoStarts());
int32 showStatusIndex = settings->ShowStatusWindow();
BMenuItem *item = fStatusModeField->Menu()->ItemAt(showStatusIndex);
if (item) {
item->SetMarked(true);
// send live update to the server by simulating a menu click
BMessage msg(kMsgShowStatusWindowChanged);
msg.AddInt32("ShowStatusWindow", showStatusIndex);
PostMessage(&msg);
}
return B_OK;
}
BPopUpMenu*
AutoConfigView::_SetupProtocolMenu()
{
BPopUpMenu* menu = new BPopUpMenu(B_TRANSLATE("Choose Protocol"));
// TODO: use path finder!
for (int i = 0; i < 2; i++) {
BPath path;
status_t status = find_directory((i == 0) ? B_USER_ADDONS_DIRECTORY :
B_BEOS_ADDONS_DIRECTORY, &path);
if (status != B_OK)
return menu;
path.Append("mail_daemon");
path.Append("inbound_protocols");
BDirectory dir(path.Path());
entry_ref protocolRef;
while (dir.GetNextRef(&protocolRef) == B_OK)
{
BEntry entry(&protocolRef);
BMessage* msg = new BMessage(kProtokollChangedMsg);
BMenuItem* item = new BMenuItem(entry.Name(), msg);
menu->AddItem(item);
msg->AddRef("protocol", &protocolRef);
item->SetMarked(true);
}
}
// make imap default protocol if existing
BMenuItem* imapItem = menu->FindItem("IMAP");
if (imapItem)
imapItem->SetMarked(true);
return menu;
}
void
SettingsView::UpdateFromSettings()
{
int32 value = int32(fSettings.ClickSpeed() / 1000);
// slow = 1000000, fast = 0
fClickSpeedSlider->SetValue(value);
value = int32((log(fSettings.MouseSpeed() / 8192.0) / log(2)) * 1000 / 6);
// slow = 8192, fast = 524287
fMouseSpeedSlider->SetValue(value);
value = int32(sqrt(fSettings.AccelerationFactor() / 16384.0) * 1000 / 4);
// slow = 0, fast = 262144
fAccelerationSlider->SetValue(value);
BMenuItem* item = fTypeMenu->ItemAt(fSettings.MouseType() - 1);
if (item != NULL)
item->SetMarked(true);
fMouseView->SetMouseType(fSettings.MouseType());
item = fFocusMenu->ItemAt(mouse_mode_to_index(fSettings.MouseMode()));
if (item != NULL)
item->SetMarked(true);
item = fFocusFollowsMouseMenu->ItemAt(
focus_follows_mouse_mode_to_index(fSettings.FocusFollowsMouseMode()));
if (item != NULL)
item->SetMarked(true);
fFocusFollowsMouseMenu->SetEnabled(fSettings.MouseMode()
== B_FOCUS_FOLLOWS_MOUSE);
fAcceptFirstClickBox->SetValue(fSettings.AcceptFirstClick()
? B_CONTROL_ON : B_CONTROL_OFF);
fAcceptFirstClickBox->SetEnabled(fSettings.MouseMode()
!= B_FOCUS_FOLLOWS_MOUSE);
}
void CInfoDialog::UpdateFields()
{
BMessage *msg = Looper()->CurrentMessage();
const char *ff, *fs;
if (msg->FindString("family", &ff) == B_NO_ERROR &&
msg->FindString("style", &fs) == B_NO_ERROR)
{
BMenuItem *item;
item = fMenu->FindMarked();
if (item)
{
item = item->Submenu()->FindMarked();
if (item) item->SetMarked(false);
fMenu->FindMarked()->SetMarked(false);
}
item = fMenu->FindItem(ff);
if (item)
{
item->SetMarked(true);
item = item->Submenu()->FindItem(fs);
if (item) item->SetMarked(true);
}
}
if (strcmp(fTypes->FindMarked()->Label(), "undefined") == 0)
{
MWarningAlert a("Please choose a real mime type");
a.Go();
}
SetEnabled("wrapfixedto", IsOn("wrapfixed"));
SetEnabled("ok", true);
SetEnabled("cancel", true);
} /* CInfoDialog::UpdateFields */
BPopUpMenu *TPrefsWindow::BuildSignatureMenu(char *sig)
{
char name[B_FILE_NAME_LENGTH];
int32 index = 0;
BEntry entry;
BFile file;
BMenuItem *item;
BMessage *msg;
BPopUpMenu *menu;
BQuery query;
BVolume vol;
BVolumeRoster volume;
menu = new BPopUpMenu("");
msg = new BMessage(P_SIG);
menu->AddItem(item = new BMenuItem(SIG_NONE, msg));
if (!strcmp(sig, SIG_NONE))
item->SetMarked(true);
menu->AddSeparatorItem();
volume.GetBootVolume(&vol);
query.SetVolume(&vol);
query.SetPredicate("_signature = *");
query.Fetch();
while (query.GetNextEntry(&entry) == B_NO_ERROR) {
file.SetTo(&entry, O_RDONLY);
if (file.InitCheck() == B_NO_ERROR) {
msg = new BMessage(P_SIG);
file.ReadAttr("_signature", B_STRING_TYPE, 0, name, sizeof(name));
msg->AddString("signature", name);
menu->AddItem(item = new BMenuItem(name, msg));
if (!strcmp(sig, name))
item->SetMarked(true);
}
}
return menu;
}
void
AppWindowPrefsView::SetEncodingItem(int32 encoding)
{
BMenuItem *item (NULL);
for (int32 i = 0; i < fEncodings->Menu()->CountItems(); i++)
{
item = fEncodings->Menu()->ItemAt(i);
if (item->Message()->FindInt32("encoding") == encoding)
{
item->SetMarked(true);
break;
}
}
}
status_t
DisplayView::Load()
{
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
return B_ERROR;
path.Append(kSettingsDirectory);
if (create_directory(path.Path(), 0755) != B_OK) {
BAlert* alert = new BAlert("",
B_TRANSLATE("There was a problem saving the preferences.\n"
"It's possible you don't have write access to the "
"settings directory."), B_TRANSLATE("OK"), NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
(void)alert->Go();
}
path.Append(kDisplaySettings);
BFile file(path.Path(), B_READ_ONLY);
BMessage settings;
settings.Unflatten(&file);
char buffer[255];
int32 setting;
BMenuItem* item = NULL;
float width;
if (settings.FindFloat(kWidthName, &width) != B_OK)
width = kDefaultWidth;
(void)sprintf(buffer, "%.2f", width);
fWindowWidth->SetText(buffer);
icon_size iconSize;
if (settings.FindInt32(kIconSizeName, &setting) != B_OK)
iconSize = kDefaultIconSize;
else
iconSize = (icon_size)setting;
if (iconSize == B_MINI_ICON)
item = fIconSize->ItemAt(0);
else
item = fIconSize->ItemAt(1);
if (item)
item->SetMarked(true);
return B_OK;
}
void ArpFontControl::SetFont(const ArpFont& font)
{
if (!mFontCtrl || !mSizeCtrl) return;
mSizeCtrl->SetValue(int32(font.Size()));
BMenu* m = mFontCtrl->Menu();
if (!m) return;
BString16 family = font.Family();
BMenuItem* item;
for (int32 k = 0; (item = m->ItemAt(k)) != 0; k++) {
if (family == item->Label()) {
item->SetMarked(true);
}
}
}
void
AppearancePrefView::_MarkSelectedFont(const char* family, const char* style,
const char* size)
{
char fontMenuLabel[134];
snprintf(fontMenuLabel, sizeof(fontMenuLabel), "%s - %s", family, style);
// mark the selected font
BMenuItem* selectedFont = fFontField->Menu()->FindItem(fontMenuLabel);
if (selectedFont != NULL)
selectedFont->SetMarked(true);
// mark the selected font size on all font menus
for (int32 i = 0; i < fFontField->Menu()->CountItems(); i++) {
BMenu* fontSizeMenu = fFontField->Menu()->SubmenuAt(i);
if (fontSizeMenu == NULL)
continue;
BMenuItem* item = fontSizeMenu->FindItem(size);
if (item != NULL)
item->SetMarked(true);
}
}
static void add_device_menu_items(BMenu* menu)
{
if (!menu) return;
BString markedLabel;
BMenuItem* item = menu->FindMarked();
if (item) markedLabel = item->Label();
menu->RemoveItems(0, menu->CountItems(), true);
AmDeviceRoster* roster = AmDeviceRoster::Default();
if (roster) {
vector<BMenuItem*> items;
BString mfg, name, key;
bool isValid;
for (uint32 k = 0; roster->GetDeviceInfo(k, mfg, name, key, NULL, &isValid) == B_OK; k++) {
if (isValid) {
BString label = AmDeviceI::MakeLabel(mfg, name);
BMessage* msg = new BMessage(DEVICE_MSG);
if (msg) {
if (mfg.Length() > 0) msg->AddString(DEV_MFG_STR, mfg);
if (name.Length() > 0) msg->AddString(DEV_NAME_STR, name);
item = new BMenuItem(label.String(), msg);
if (item) items.push_back(item);
}
}
}
sort(items.begin(), items.end(), sort_items);
for (uint32 k = 0; k < items.size(); k++) menu->AddItem(items[k]);
items.resize(0);
}
/* Set the marked to whatever it previously was. It's important to try
* to find the marked BEFORE adding the separator item -- otherwise, if
* there is no marked label, it will find the separator item.
*/
BMenuItem* marked = menu->FindItem(markedLabel.String() );
if (menu->CountItems() > 0) menu->AddSeparatorItem();
BMenuItem* noneItem = new BMenuItem(NONE_STR, new BMessage(DEVICE_MSG));
if (noneItem) menu->AddItem(noneItem);
item = new BMenuItem(VARIOUS_STR, NULL);
if (item) {
menu->AddItem(item);
item->SetEnabled(false);
}
/* Now set the actual marked item.
*/
if (!marked) marked = noneItem;
if (!marked) marked = menu->ItemAt(0);
if (marked) marked->SetMarked(true);
}
void MediaRoutingView::showContextMenu(
BPoint point)
{
D_METHOD(("MediaRoutingView::showContextMenu()\n"));
BPopUpMenu *menu = new BPopUpMenu("MediaRoutingView PopUp", false, false, B_ITEMS_IN_COLUMN);
menu->SetFont(be_plain_font);
// add layout options
BMenuItem *item;
BMessage *message = new BMessage(M_LAYOUT_CHANGED);
message->AddInt32("layout", M_ICON_VIEW);
menu->AddItem(item = new BMenuItem("Icon View", message));
if (m_layout == M_ICON_VIEW)
{
item->SetMarked(true);
}
message = new BMessage(M_LAYOUT_CHANGED);
message->AddInt32("layout", M_MINI_ICON_VIEW);
menu->AddItem(item = new BMenuItem("Mini Icon View", message));
if (m_layout == M_MINI_ICON_VIEW)
{
item->SetMarked(true);
}
menu->AddSeparatorItem();
// add 'CleanUp' command
menu->AddItem(new BMenuItem("Clean Up", new BMessage(M_CLEANUP_REQUESTED), 'K'));
// add 'Select All' command
menu->AddItem(new BMenuItem("Select All", new BMessage(M_SELECT_ALL), 'A'));
menu->SetTargetForItems(this);
ConvertToScreen(&point);
point -= BPoint(1.0, 1.0);
menu->Go(point, true, true, true);
}
void SeqStudioWindow::MenusBeginning()
{
inherited::MenusBeginning();
BMenuBar* bar = KeyMenuBar();
if (!bar) return;
BColumnListView* table = dynamic_cast<BColumnListView*>( FindView(ENDPOINT_LIST_STR) );
if (!table) return;
if (mDeviceCtrl && mDeviceCtrl->Menu() ) add_device_menu_items(mDeviceCtrl->Menu() );
// MIDI Port menu
if (mPortMenu) {
bool deleteEnabled = false;
_EndpointRow* r = dynamic_cast<_EndpointRow*>(table->CurrentSelection() );
if (r && !r->mIsValid && r->mEndpoint.channel < 0) deleteEnabled = true;
BMenuItem* deleteItem = mPortMenu->FindItem(DELETE_STR);
if (deleteItem && deleteItem->IsEnabled() != deleteEnabled) deleteItem->SetEnabled(deleteEnabled);
}
// Attributes menu
BMenu* menu;
BMenuItem* item;
if ( (menu = bar->SubmenuAt(ATTRIBUTES_MENU_INDEX)) != NULL) {
for (int32 k = 0; (item = menu->ItemAt(k)) != NULL; k++) {
const char* n;
if (item->Message() && item->Message()->FindString(COLUMN_NAME_STR, &n) == B_OK) {
BColumn* col = column_named(n, table);
if (col && col->IsVisible() ) {
if (!item->IsMarked() ) item->SetMarked(true);
} else {
if (item->IsMarked() ) item->SetMarked(false);
}
}
}
}
}
void
GLObject::MenuInvoked(BPoint point)
{
BPopUpMenu* m = new BPopUpMenu("Object",false,false);
BMenuItem* i;
int c = 1;
m->AddItem(i = new BMenuItem("White",NULL));
if (color == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Yellow",NULL));
if (color == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Blue",NULL));
if (color == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Red",NULL));
if (color == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Green",NULL));
if (color == c++)
i->SetMarked(true);
m->AddSeparatorItem();
c = 0;
m->AddItem(i = new BMenuItem("Solid",NULL));
if (solidity == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Translucent",NULL));
if (solidity == c++)
i->SetMarked(true);
m->AddItem(i = new BMenuItem("Transparent",NULL));
if (solidity == c++)
i->SetMarked(true);
i = m->Go(point);
int32 index = m->IndexOf(i);
delete m;
if (index < 5) {
color = index+1;
} else if (index > 5) {
solidity = index-6;
}
changed = true;
setEvent(fObjView->drawEvent);
}
void
PPPoEView::ReloadInterfaces()
{
// delete all items and request a new bunch from the pppoe kernel module
BMenu *menu = fInterface->Menu();
while(menu->CountItems() > 2)
delete menu->RemoveItem((int32) 0);
fOtherInterface->SetLabel(kLabelOtherInterface);
PPPManager manager;
char *interfaces = new char[8192];
// reserve enough space for approximately 512 entries
int32 count = manager.ControlModule("pppoe", PPPoE_GET_INTERFACES, interfaces,
8192);
BMenuItem *item;
char *name = interfaces;
int32 insertAt;
for(int32 index = 0; index < count; index++) {
item = new BMenuItem(name, new BMessage(kMsgSelectInterface));
insertAt = FindNextMenuInsertionIndex(menu, name);
if(insertAt > menu->CountItems() - 2)
insertAt = menu->CountItems() - 2;
item->SetTarget(this);
menu->AddItem(item, insertAt);
name += strlen(name) + 1;
}
// set interface or some default value if nothing was found
if(Addon()->InterfaceName() && strlen(Addon()->InterfaceName()) > 0)
fInterfaceName = Addon()->InterfaceName();
else if(count > 0)
fInterfaceName = interfaces;
else
fInterfaceName = "";
delete interfaces;
item = menu->FindItem(fInterfaceName.String());
if(item && menu->IndexOf(item) <= menu->CountItems() - 2)
item->SetMarked(true);
else if(Addon()->InterfaceName()) {
BString label(kLabelOtherInterface);
label << " " << fInterfaceName;
fOtherInterface->SetLabel(label.String());
fOtherInterface->SetMarked(true);
}
}
BMenuBar*
KeymapWindow::_CreateMenu()
{
BMenuBar* menuBar = new BMenuBar(Bounds(), "menubar");
// Create the File menu
BMenu* menu = new BMenu(B_TRANSLATE("File"));
menu->AddItem(new BMenuItem(B_TRANSLATE("Open" B_UTF8_ELLIPSIS),
new BMessage(kMsgMenuFileOpen), 'O'));
menu->AddItem(new BMenuItem(B_TRANSLATE("Save as" B_UTF8_ELLIPSIS),
new BMessage(kMsgMenuFileSaveAs)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(
B_TRANSLATE("Set modifier keys" B_UTF8_ELLIPSIS),
new BMessage(kMsgShowModifierKeysWindow)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
menuBar->AddItem(menu);
// Create keyboard layout menu
fLayoutMenu = new BMenu(B_TRANSLATE("Layout"));
_AddKeyboardLayouts(fLayoutMenu);
menuBar->AddItem(fLayoutMenu);
// Create the Font menu
fFontMenu = new BMenu(B_TRANSLATE("Font"));
fFontMenu->SetRadioMode(true);
int32 numFamilies = count_font_families();
font_family family, currentFamily;
font_style currentStyle;
uint32 flags;
be_plain_font->GetFamilyAndStyle(¤tFamily, ¤tStyle);
for (int32 i = 0; i < numFamilies; i++) {
if (get_font_family(i, &family, &flags) == B_OK) {
BMenuItem *item =
new BMenuItem(family, new BMessage(kMsgMenuFontChanged));
fFontMenu->AddItem(item);
if (!strcmp(family, currentFamily))
item->SetMarked(true);
}
}
menuBar->AddItem(fFontMenu);
return menuBar;
}
void
NetPulseView::MouseDown(BPoint where)
{
int32 buttons;
int32 clicks;
if (Window()->CurrentMessage()->FindInt32("buttons", &buttons) != B_OK
|| Window()->CurrentMessage()->FindInt32("clicks", &clicks) != B_OK) {
return;
}
if (buttons == B_SECONDARY_MOUSE_BUTTON) {
BPopUpMenu* popUpMenu = new BPopUpMenu("NetPulseMenu");
popUpMenu->AddItem(new BMenuItem("Connect",
new BMessage(kMsgConnect)));
popUpMenu->AddItem(new BMenuItem("Disconnect",
new BMessage(kMsgDisconnect)));
popUpMenu->AddSeparatorItem();
popUpMenu->AddItem(new BMenuItem("Statistics...",
new BMessage(kMsgStatistics)));
popUpMenu->AddSeparatorItem();
uint32 cookie = 0;
BNetworkInterface interface;
BNetworkRoster& roster = BNetworkRoster::Default();
while (roster.GetNextInterface(&cookie, interface) == B_OK) {
const char* name = interface.Name();
if (strncmp(name, "loop", 4) != 0) {
BMenuItem* menuItem = new BMenuItem(name,
new BMessage(kMsgChangeInterface + cookie));
menuItem->SetMarked(cookie == fCookie);
popUpMenu->AddItem(menuItem);
}
}
popUpMenu->AddSeparatorItem();
popUpMenu->AddItem(new BMenuItem("Quit", new BMessage(kMsgQuit)));
popUpMenu->SetTargetForItems(this);
popUpMenu->FindItem(kMsgConnect)->SetEnabled(!fEnable && fCookie != 0);
popUpMenu->FindItem(kMsgDisconnect)->SetEnabled(fEnable && fCookie != 0);
popUpMenu->FindItem(kMsgStatistics)->SetEnabled(fEnable && fCookie != 0);
popUpMenu->Go(ConvertToScreen(BPoint(0, 0)), true, false, false);
delete popUpMenu;
} else if (buttons == B_PRIMARY_MOUSE_BUTTON && clicks == 2)
be_roster->Launch("application/x-vnd.Haiku-Network");
}
void TCueSheetWindow::AdjustStageMenu()
{
BMenu* theMenu = fAppMenu->GetStageMenu();
if (theMenu) {
// Stage Item
//BMenuItem *stageItem = theMenu->FindItem(WINDOWS_STAGE_MSG);
//if (stageItem)
// Live Drag Item
BMenuItem* updateItem = theMenu->FindItem(STAGE_LUPDATE_MSG);
if (updateItem)
updateItem->SetMarked( fCueSheetView->GetLiveUpdate() );
}
}
void RIFFWAVESettingsWindow::GetSettings(void)
{
PString tempStr;
char *tempPoi;
BMenuItem *item;
// Set the output format
tempStr = useSettings->GetStringEntryValue("General", "OutputFormat");
tempPoi = tempStr.GetString();
item = formatPop->FindItem(tempPoi);
if (item != NULL)
item->SetMarked(true);
tempStr.FreeBuffer(tempPoi);
}
BMenuItem*
ShowImageWindow::_AddDelayItem(BMenu* menu, const char* label, bigtime_t delay)
{
BMessage* message = new BMessage(MSG_SLIDE_SHOW_DELAY);
message->AddInt64("delay", delay);
BMenuItem* item = new BMenuItem(label, message, 0);
item->SetTarget(this);
if (delay == fSlideShowDelay)
item->SetMarked(true);
menu->AddItem(item);
return item;
}
BPopUpMenu*
TPrefsWindow::_BuildEncodingMenu(uint32 encoding)
{
BMenuItem* item;
BMessage* msg;
BPopUpMenu* menu;
menu = new BPopUpMenu("");
BCharacterSetRoster roster;
BCharacterSet charset;
while (roster.GetNextCharacterSet(&charset) == B_NO_ERROR) {
BString name(charset.GetPrintName());
const char* mime = charset.GetMIMEName();
if (mime)
name << " (" << mime << ")";
msg = new BMessage(P_ENC);
uint32 convert_id;
if ((mime == 0) || (strcasecmp(mime, "UTF-8") != 0))
convert_id = charset.GetConversionID();
else
convert_id = B_MAIL_UTF8_CONVERSION;
msg->AddInt32("encoding", convert_id);
menu->AddItem(item = new BMenuItem(name.String(), msg));
if (convert_id == encoding)
item->SetMarked(true);
}
msg = new BMessage(P_ENC);
msg->AddInt32("encoding", B_MAIL_US_ASCII_CONVERSION);
menu->AddItem(item = new BMenuItem("US-ASCII", msg));
if (encoding == B_MAIL_US_ASCII_CONVERSION)
item->SetMarked(true);
return menu;
}
BPopUpMenu*
TPrefsWindow::_BuildAttachAttributesMenu(bool attachAttributes)
{
BMenuItem* item;
BMessage* msg;
BPopUpMenu* menu;
menu = new BPopUpMenu("");
msg = new BMessage(P_ATTACH_ATTRIBUTES);
msg->AddBool("attachAttributes", true);
menu->AddItem(item = new BMenuItem(
B_TRANSLATE("Include file attributes in attachments"), msg));
if (attachAttributes)
item->SetMarked(true);
msg = new BMessage(P_ATTACH_ATTRIBUTES);
msg->AddInt32("attachAttributes", false);
menu->AddItem(item = new BMenuItem(
B_TRANSLATE("No file attributes, just plain data"), msg));
if (!attachAttributes)
item->SetMarked(true);
return menu;
}
/*static*/ BMenu*
AppearancePrefView::_MakeSizeMenu(uint32 command, uint8 defaultSize)
{
BPopUpMenu* menu = new BPopUpMenu("size");
int32 sizes[] = {9, 10, 11, 12, 14, 16, 18, 0};
bool found = false;
for (uint32 i = 0; sizes[i]; i++) {
BString string;
string << sizes[i];
BMenuItem* item = new BMenuItem(string.String(), new BMessage(command));
menu->AddItem(item);
if (sizes[i] == defaultSize) {
item->SetMarked(true);
found = true;
}
}
if (!found) {
for (uint32 i = 0; sizes[i]; i++) {
if (sizes[i] > defaultSize) {
BString string;
string << defaultSize;
BMenuItem* item = new BMenuItem(string.String(),
new BMessage(command));
item->SetMarked(true);
menu->AddItem(item, i);
break;
}
}
}
return menu;
}
void
FontSelectionView::UpdateFontsMenu()
{
int32 numFamilies = count_font_families();
fFontsMenu->RemoveItems(0, fFontsMenu->CountItems(), true);
BFont font = fCurrentFont;
font_family currentFamily;
font_style currentStyle;
font.GetFamilyAndStyle(¤tFamily, ¤tStyle);
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
uint32 flags;
if (get_font_family(i, &family, &flags) != B_OK)
continue;
// if we're setting the fixed font, we only want to show fixed fonts
if (!strcmp(Name(), "fixed") && (flags & B_IS_FIXED) == 0)
continue;
font.SetFamilyAndFace(family, B_REGULAR_FACE);
BMessage* message = new BMessage(kMsgSetFamily);
message->AddString("family", family);
message->AddString("name", Name());
BMenuItem* familyItem;
if (fStylesMenuField != NULL) {
familyItem = new BMenuItem(family, message);
} else {
// Each family item has a submenu with all styles for that font.
BMenu* stylesMenu = new BMenu(family);
_AddStylesToMenu(font, stylesMenu);
familyItem = new BMenuItem(stylesMenu, message);
}
familyItem->SetMarked(strcmp(family, currentFamily) == 0);
fFontsMenu->AddItem(familyItem);
familyItem->SetTarget(this);
}
// Separate styles menu for only the current font.
if (fStylesMenuField != NULL)
_AddStylesToMenu(fCurrentFont, fStylesMenuField->Menu());
}
void
ShowImageWindow::_MarkSlideShowDelay(bigtime_t delay)
{
const int32 count = fSlideShowDelayMenu->CountItems();
for (int32 i = 0; i < count; i ++) {
BMenuItem* item = fSlideShowDelayMenu->ItemAt(i);
if (item != NULL) {
bigtime_t itemDelay;
if (item->Message()->FindInt64("delay", &itemDelay) == B_OK
&& itemDelay == delay) {
item->SetMarked(true);
return;
}
}
}
}
void
ShowImageWindow::_MarkSlideShowDelay(float value)
{
const int32 n = fSlideShowDelay->CountItems();
float v;
for (int32 i = 0; i < n; i ++) {
BMenuItem* item = fSlideShowDelay->ItemAt(i);
if (item) {
if (item->Message()->FindFloat("value", &v) == B_OK && v == value) {
if (!item->IsMarked())
item->SetMarked(true);
return;
}
}
}
}
BMenuItem*
ShowImageWindow::_AddDelayItem(BMenu *menu, const char *label, float value)
{
BMessage* message = new BMessage(MSG_SLIDE_SHOW_DELAY);
message->AddFloat("value", value);
BMenuItem* item = new BMenuItem(label, message, 0);
item->SetTarget(this);
bool marked = fImageView->GetSlideShowDelay() == value;
if (marked)
item->SetMarked(true);
menu->AddItem(item);
return item;
}
