BMenuItem* TTransitionMenu::GetDiagonalWipesMenuItem(int16 menuID)
{
BMenuItem* wipesItem = FindItem("Diagonal Wipes");
BMenu* subMenu = wipesItem->Submenu();
switch (menuID)
{
// Wipes Submenu
case kWipeTopLeftBottomRight:
return (subMenu->FindItem(TRAN_WIPE_TOP_LEFT_BOTTOM_RIGHT_MSG) );
break;
case kWipeTopRightBottomLeft:
return (subMenu->FindItem(TRAN_WIPE_TOP_RIGHT_BOTTON_LEFT_MSG) );
break;
case kWipeBottomLeftTopRight:
return (subMenu->FindItem(TRAN_WIPE_BOTTOM_LEFT_TOP_RIGHT_MSG) );
break;
case kWipeBottomRightTopLeft:
return (subMenu->FindItem(TRAN_WIPE_BOTTOM_RIGHT_TOP_LEFT_MSG) );
break;
default:
return NULL;
}
}
BMenuItem* TTransitionMenu::GetStraightWipesMenuItem(int16 menuID)
{
BMenuItem* wipesItem = FindItem("Straight Wipes");
BMenu* subMenu = wipesItem->Submenu();
switch (menuID)
{
// Wipes Submenu
case kWipeRight:
return (subMenu->FindItem(TRAN_WIPE_RIGHT_MSG) );
break;
case kWipeLeft:
return (subMenu->FindItem(TRAN_WIPE_LEFT_MSG) );
break;
case kWipeDown:
return (subMenu->FindItem(TRAN_WIPE_DOWN_MSG) );
break;
case kWipeTop:
return (subMenu->FindItem(TRAN_WIPE_UP_MSG) );
break;
default:
return NULL;
}
}
void TCueSheetWindow::AdjustFileMenu()
{
BMenu* theMenu = fAppMenu->GetFileMenu();
if (theMenu) {
// Save item
BMenuItem* saveItem = theMenu->FindItem(FILE_SAVE_MSG);
if (saveItem) {
if (fCueSheetView->IsDirty())
saveItem->SetEnabled(true);
else
saveItem->SetEnabled(false);
}
// Revert item
BMenuItem* revertItem = theMenu->FindItem(FILE_REVERT_MSG);
if (saveItem) {
if (fCueSheetView->IsDirty())
revertItem->SetEnabled(true);
else
revertItem->SetEnabled(false);
}
}
}
void
PPPoEView::MessageReceived(BMessage *message)
{
switch(message->what) {
case kMsgSelectInterface: {
BMenuItem *item = fInterface->Menu()->FindMarked();
if(item)
fInterfaceName = item->Label();
} break;
case kMsgSelectOther:
(new TextRequestDialog("InterfaceName", NULL, kRequestInterfaceName,
fInterfaceName.String()))->Go(new BInvoker(
new BMessage(kMsgFinishSelectOther), this));
break;
case kMsgFinishSelectOther: {
int32 which;
message->FindInt32("which", &which);
const char *name = message->FindString("text");
BMenu *menu = fInterface->Menu();
BMenuItem *item;
if(which != 1 || !name || strlen(name) == 0) {
item = menu->FindItem(fInterfaceName.String());
if(item && menu->IndexOf(item) <= menu->CountItems() - 2)
item->SetMarked(true);
else
fOtherInterface->SetMarked(true);
return;
}
fInterfaceName = name;
item = menu->FindItem(fInterfaceName.String());
if(item && menu->IndexOf(item) <= menu->CountItems() - 2) {
item->SetMarked(true);
return;
}
BString label(kLabelOtherInterface);
label << " " << name;
fOtherInterface->SetLabel(label.String());
fOtherInterface->SetMarked(true);
// XXX: this is needed to tell the owning menu to update its label
} break;
default:
BView::MessageReceived(message);
}
}
void
MainWindow::MenusBeginning()
{
BRow* sel = teamView->CurrentSelection();
bool is_sel = (sel != NULL);
BMenu *menu = (BMenu *)FindView("MenuBar");
BMenuItem *item = menu->FindItem(IE_MAINWINDOW_MAINKILL);
if (item) item->SetEnabled(is_sel);
item = menu->FindItem(IE_MAINWINDOW_MAINSUSPEND);
if (item) item->SetEnabled(is_sel);
item = menu->FindItem(IE_MAINWINDOW_MAINRESUME);
if (item) item->SetEnabled(is_sel);
priorityMenu->SetEnabled(is_sel);
priorityMenu->Update();
}
void
ControlView::_UpdateAndSendStyle(const BMessage* message)
{
_DeselectOldItems();
const char* style;
const char* family;
if (message->FindString("_style", &style) == B_OK
&& message->FindString("_family", &family) == B_OK) {
BMenuItem* familyItem = fFontFamilyMenu->FindItem(family);
if (familyItem && !familyItem->IsMarked()) {
familyItem->SetMarked(true);
BMenu* submenu = familyItem->Submenu();
if (submenu) {
BMenuItem* styleItem = submenu->FindItem(style);
if (styleItem && !styleItem->IsMarked())
styleItem->SetMarked(true);
}
printf("Family: %s, Style: %s\n", family, style);
}
BString string;
string << family << " " << style;
if (fFontMenuField)
fFontMenuField->MenuItem()->SetLabel(string.String());
}
BMessage fontMsg(FONTSTYLE_CHANGED_MSG);
if (fontMsg.AddMessage("_fontMessage", message) == B_OK)
fMessenger->SendMessage(&fontMsg);
}
/***********************************************************
* SetFrom
***********************************************************/
void
HAddressView::SetFrom(const char* in_address)
{
if( ::strlen(in_address) == 0)
return;
BString address(in_address);
// Compare existing accounts
char name[B_FILE_NAME_LENGTH];
BPath path;
::find_directory(B_USER_SETTINGS_DIRECTORY,&path);
path.Append(APP_NAME);
path.Append("Accounts");
BDirectory dir(path.Path());
status_t err = B_OK;
BEntry entry;
bool changed = false;
while(err == B_OK)
{
if( (err = dir.GetNextEntry(&entry)) != B_OK )
break;
BFile file(&entry,B_READ_ONLY);
if(file.InitCheck() == B_OK && entry.IsFile())
{
BMessage msg;
msg.Unflatten(&file);
BString myAddress;
PRINT(("%s\n",in_address));
if(msg.FindString("address",&myAddress) != B_OK)
myAddress = "";
// Change account
if(address.FindFirst(myAddress) != B_ERROR)
{
entry.GetName(name);
ChangeAccount(name);
// Set From menu
BMenuField *field = cast_as(FindView("FromMenu"),BMenuField);
BMenu *menu = field->Menu();
BMenuItem *item = menu->FindItem(name);
if(item)
item->SetMarked(true);
changed=true;
break;
}
}
}
if(!changed && cast_as(Window()->FindView("HMailView"),BTextView))
{
BMenuField *field = cast_as(FindView("FromMenu"),BMenuField);
BMenuItem *item(NULL);
item = field->Menu()->FindMarked();
if(item)
{
ChangeAccount(item->Label());
item->SetMarked(true);
}
}
}
GDWindow::GDWindow(BRect frame)
: BWindow(frame, "GrafDemo 4.6", B_DOCUMENT_WINDOW,0)
{
Lock();
// Add the graph to the window
BRect grafRect = Bounds();
grafRect.top += mb_height + 2;
mGraphView= new GDView(grafRect);
AddChild(mGraphView);
SetSizeLimits(frame.right - frame.left,9999,frame.bottom - frame.top,9999);
// Add the main menu bar and menus
BRect menuRect(0,0,1000,mb_height);
BMenuBar* menuBar = new BMenuBar(menuRect,"MB");
BMenu* fileMenu = new BMenu("File");
BMenuItem* aboutItem = new BMenuItem("About...",new BMessage(B_ABOUT_REQUESTED));
aboutItem->SetTarget(be_app);
fileMenu->AddItem(aboutItem);
fileMenu->AddSeparatorItem();
fileMenu->AddItem(new BMenuItem("Quit",new BMessage(B_QUIT_REQUESTED)));
menuBar->AddItem(fileMenu);
BMenu* editMenu = new BMenu("Edit");
editMenu->AddItem(new BMenuItem("Erase",new BMessage(G_erase_data)));
editMenu->AddItem(new BMenuItem("Reset Axes",new BMessage(G_reset_axes)));
editMenu->SetTargetForItems(mGraphView);
menuBar->AddItem(editMenu);
BMenu* paramsMenu = new BMenu("Params");
BMessage* cFitMesg = new BMessage(G_set_params);
cFitMesg->AddInt16(pName,0);
BMessage* p2Mesg = new BMessage(G_set_params);
p2Mesg->AddInt16(pName,2);
BMessage* p3Mesg = new BMessage(G_set_params);
p3Mesg->AddInt16(pName,3);
BMessage* p4Mesg = new BMessage(G_set_params);
p4Mesg->AddInt16(pName,4);
paramsMenu->AddItem(new BMenuItem("Cubic Spline",cFitMesg));
paramsMenu->AddSeparatorItem();
paramsMenu->AddItem(new BMenuItem("1st Order",p2Mesg));
paramsMenu->AddItem(new BMenuItem("2nd Order",p3Mesg));
paramsMenu->AddItem(new BMenuItem("3rd Order",p4Mesg));
paramsMenu->SetRadioMode(true);
paramsMenu->FindItem("2nd Order")->SetMarked(true);
paramsMenu->SetTargetForItems(mGraphView);
menuBar->AddItem(paramsMenu);
BMenu* axisMenu = new BMenu("Axes");
axisMenu->AddItem(new BMenuItem("Set Axes"B_UTF8_ELLIPSIS,new BMessage(G_change_axis)));
axisMenu->SetTargetForItems(mGraphView);
menuBar->AddItem(axisMenu);
AddChild(menuBar);
Unlock();
}
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();
}
BMenuItem* TTransitionMenu::GetCurtainsMenuItem(int16 menuID)
{
BMenuItem* wipesItem = FindItem("Curtains");
BMenu* subMenu = wipesItem->Submenu();
switch (menuID)
{
case kCurtainsIn:
return (subMenu->FindItem(TRAN_CURTAINS_IN_MSG) );
break;
case kCurtainsOut:
return (subMenu->FindItem(TRAN_CURTAINS_OUT_MSG) );
break;
default:
return NULL;
}
}
void SeqManageRosterWindow::MenusBeginning()
{
inherited::MenusBeginning();
BMenuBar* bar = KeyMenuBar();
if (!bar) return;
BColumnListView* table = dynamic_cast<BColumnListView*>( FindView(TABLE_STR) );
if (!table) return;
BMenu* menu;
BMenuItem* item;
// Entry menu
bool canEdit = false, canDuplicate = false;
BString key, filePath;
bool readOnly;
if (GetSelectionInfo(key, filePath, &readOnly) == B_OK) {
canEdit = !readOnly;
canDuplicate = true;
}
if ( (menu = bar->SubmenuAt(ENTRY_MENU_INDEX)) != NULL) {
if ( (item = menu->FindItem(EDIT_ENTRY_MSG)) != NULL) item->SetEnabled(canEdit);
if ( (item = menu->FindItem(DUPLICATE_ENTRY_MSG)) != NULL) item->SetEnabled(canDuplicate);
if ( (item = menu->FindItem(DELETE_ENTRY_MSG)) != NULL) item->SetEnabled(canEdit);
}
// Attributes menu
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 TCueSheetWindow::AdjustCueMenu()
{
BMenu* theMenu = fAppMenu->GetCueMenu();
if (theMenu) {
// Get Cue Info
// Enable if any items are selected
BMenuItem* cueInfoItem = theMenu->FindItem(CUESHEET_GETINFO_MSG);
if (cueInfoItem)
cueInfoItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Default Cue Setup
// Enable if any items are selected
//BMenuItem *cueInfoItem = theMenu->FindItem(CUESHEET_GETINFO_MSG);
//if (cueInfoItem)
// cueInfoItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Show Cue Contents
// Enable if any items are selected
BMenuItem* showContentsItem = theMenu->FindItem(CUESHEET_SHOWCONTENTS_MSG);
if (showContentsItem)
showContentsItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Show All Cue Contents
// Enable if we have cues
BMenuItem* showAllContentsItem = theMenu->FindItem(CUESHEET_SHOWALLCONTENTS_MSG);
if (showAllContentsItem)
showAllContentsItem->SetEnabled( fCueSheetView->HasCues() );
// Hide All Cue Contents
// Enable if we have cues
BMenuItem* hideAllContentsItem = theMenu->FindItem(CUESHEET_HIDEALLCONTENTS_MSG);
if (hideAllContentsItem)
hideAllContentsItem->SetEnabled( fCueSheetView->HasCues() );
// Cue Setup
// Enable if any items are selected
BMenuItem* setupItem = theMenu->FindItem(CUESHEET_SETUP_MSG);
if (setupItem)
setupItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Open Cue Editor
// Enable if any items are selected
BMenuItem* editItem = theMenu->FindItem(CUESHEET_EDIT_MSG);
if (editItem)
editItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Add Keyframes
// Enable if any items are selected
BMenuItem* keyframeItem = theMenu->FindItem(CUESHEET_KEYFRAME_MSG);
if (keyframeItem)
keyframeItem->SetEnabled( fCueSheetView->ItemsSelected() );
}
}
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);
}
}
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
ControlView::_UpdateAndSendFamily(const BMessage* message)
{
_DeselectOldItems();
font_family family;
font_style style;
if (message->FindString("_family", (const char **)&family) == B_OK) {
char* name;
type_code typeFound = 0;
int32 countFound = 0;
if (message->GetInfo(B_ANY_TYPE, 0, &name, &typeFound,
&countFound) == B_OK) {
if (typeFound == B_STRING_TYPE) {
BString string;
if (message->FindString(name, 0, &string) == B_OK)
printf("Family: %s\n", string.String());
}
}
BMenuItem* markedItem = fFontFamilyMenu->FindItem(family);
if (!markedItem)
return;
markedItem->SetMarked(true);
get_font_style(family, 0, &style);
BString string;
string << family << " " << style;
if (fFontMenuField)
fFontMenuField->MenuItem()->SetLabel(string.String());
BMenu* submenu = markedItem->Submenu();
if (submenu) {
BMenuItem* styleItem = submenu->FindItem(style);
if (styleItem && !styleItem->IsMarked())
styleItem->SetMarked(true);
}
BMessage fontMsg(FONTFAMILY_CHANGED_MSG);
if (fontMsg.AddMessage("_fontMessage", message) == B_OK)
fMessenger->SendMessage(&fontMsg);
}
}
BMenuItem* TTransitionMenu::GetRevealMenuItem(int16 menuID)
{
BMenuItem* wipesItem = FindItem("Reveal");
BMenu* subMenu = wipesItem->Submenu();
switch (menuID)
{
case kRevealRight:
return (subMenu->FindItem(TRAN_REVEAL_RIGHT_MSG) );
break;
case kRevealLeft:
return (subMenu->FindItem(TRAN_REVEAL_LEFT_MSG) );
break;
case kRevealDown:
return (subMenu->FindItem(TRAN_REVEAL_DOWN_MSG) );
break;
case kRevealUp:
return (subMenu->FindItem(TRAN_REVEAL_UP_MSG) );
break;
case kRevealTopLeftBottomRight:
return (subMenu->FindItem(TRAN_REVEAL_TOP_LEFT_BOTTOM_RIGHT_MSG) );
break;
case kRevealTopRightBottomLeft:
return (subMenu->FindItem(TRAN_REVEAL_TOP_RIGHT_BOTTON_LEFT_MSG) );
break;
case kRevealBottomLeftTopRight:
return (subMenu->FindItem(TRAN_REVEAL_BOTTOM_LEFT_TOP_RIGHT_MSG) );
break;
case kRevealBottomRightTopLeft:
return (subMenu->FindItem(TRAN_REVEAL_BOTTOM_RIGHT_TOP_LEFT_MSG) );
break;
default:
return NULL;
}
}
BMenu*
CharacterWindow::_CreateFontMenu()
{
BMenu* menu = new BMenu(B_TRANSLATE("Font"));
BMenuItem* item;
font_family currentFamily;
font_style currentStyle;
fCharacterView->CharacterFont().GetFamilyAndStyle(¤tFamily,
¤tStyle);
int32 numFamilies = count_font_families();
menu->SetRadioMode(true);
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
if (get_font_family(i, &family) == B_OK) {
BMenu* subMenu = new BMenu(family);
menu->AddItem(new BMenuItem(subMenu,
new BMessage(kMsgFontSelected)));
int numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
font_style style;
uint32 flags;
if (get_font_style(family, j, &style, &flags) == B_OK) {
item = new BMenuItem(style, new BMessage(kMsgFontSelected));
subMenu->AddItem(item);
if (!strcmp(family, currentFamily)
&& !strcmp(style, currentStyle)) {
fSelectedFontItem = item;
item->SetMarked(true);
}
}
}
}
}
item = menu->FindItem(currentFamily);
item->SetMarked(true);
return menu;
}
void TCueSheetWindow::AdjustEditMenu()
{
BMenu* theMenu = fAppMenu->GetEditMenu();
if (theMenu) {
// Undo Item
BMenuItem* undoItem = theMenu->FindItem(EDIT_UNDO_MSG);
if (undoItem) {
if (fUndoEngine->CanUndo())
undoItem->SetEnabled(true);
else
undoItem->SetEnabled(false);
}
// Cut
// Enable if any items are selected
BMenuItem* cutItem = theMenu->FindItem(EDIT_CUT_MSG);
if (cutItem)
cutItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Copy
// Enable if any items are selected
BMenuItem* copyItem = theMenu->FindItem(EDIT_COPY_MSG);
if (copyItem)
copyItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Paste
// Enable if there is anything on the clipboard
BMenuItem* pasteItem = theMenu->FindItem(EDIT_PASTE_MSG);
if (pasteItem)
pasteItem->SetEnabled( static_cast<MuseumApp*>(be_app)->fClipboard->HasData() );
// Clear
BMenuItem* clearItem = theMenu->FindItem(EDIT_CLEAR_MSG);
if (clearItem)
clearItem->SetEnabled( fCueSheetView->ItemsSelected() );
// Select All
// Enable if there is anything to be selected
BMenuItem* selectAllItem = theMenu->FindItem(EDIT_SELECTALL_MSG);
if (selectAllItem) {
// Enable this item if there are any cues to be selected
selectAllItem->SetEnabled( fCueSheetView->HasCues() );
}
}
}
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);
}
}
void
HWindow::SetupMenuField()
{
BMenuField* menufield = dynamic_cast<BMenuField*>(FindView("filemenu"));
if (menufield == NULL)
return;
BMenu* menu = menufield->Menu();
int32 count = fEventList->CountRows();
for (int32 i = 0; i < count; i++) {
HEventRow* row = (HEventRow*)fEventList->RowAt(i);
if (row == NULL)
continue;
BPath path(row->Path());
if (path.InitCheck() != B_OK)
continue;
if (menu->FindItem(path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(path.Leaf(), msg), 0);
}
BPath path;
BDirectory dir;
BEntry entry;
BPath item_path;
status_t err = find_directory(B_BEOS_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
err = find_directory(B_USER_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
err = find_directory(B_COMMON_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
}
MainWindow::MainWindow(BRect frame)
: BWindow(frame,B_TRANSLATE_SYSTEM_NAME("BeMines"),B_TITLED_WINDOW, B_NOT_RESIZABLE),
fSmileyState(FACE_NORMAL)
{
LoadSettings();
BView *top = new BView(Bounds(),"back",B_FOLLOW_ALL,B_WILL_DRAW);
top->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
AddChild(top);
BRect r(Bounds());
r.bottom = 20;
fMenuBar = new BMenuBar(r, "menubar");
BMenu *menu = new BMenu(B_TRANSLATE("Game"));
menu->AddItem(new BMenuItem(B_TRANSLATE("New"),new BMessage(M_NEW_GAME),'N'));
BMenu *submenu = NULL;
menu->AddItem(new BMenuItem(B_TRANSLATE("Pause"),new BMessage(M_PAUSE_GAME),'P',
B_COMMAND_KEY));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("High scores"),new BMessage(M_SHOW_SCORES)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Help"),new BMessage(M_SHOW_HELP)));
menu->AddItem(new BMenuItem(B_TRANSLATE("About BeMines"),new BMessage(B_ABOUT_REQUESTED)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"), new BMessage(B_QUIT_REQUESTED), 'Q'));
fMenuBar->AddItem(menu);
menu = new BMenu(B_TRANSLATE("Settings"));
submenu = new BMenu(B_TRANSLATE("Difficulty"));
BMessage *menumsg = new BMessage(M_SET_DIFFICULTY);
menumsg->AddInt32("level",DIFFICULTY_BEGINNER);
submenu->AddItem(new BMenuItem(B_TRANSLATE("Beginner"),menumsg));
menumsg = new BMessage(M_SET_DIFFICULTY);
menumsg->AddInt32("level",DIFFICULTY_INTERMEDIATE);
submenu->AddItem(new BMenuItem(B_TRANSLATE("Intermediate"),menumsg));
menumsg = new BMessage(M_SET_DIFFICULTY);
menumsg->AddInt32("level",DIFFICULTY_EXPERT);
submenu->AddItem(new BMenuItem(B_TRANSLATE("Expert"),menumsg));
menumsg = new BMessage(M_SHOW_CUSTOM);
submenu->AddItem(new BMenuItem(B_TRANSLATE("Custom" B_UTF8_ELLIPSIS),menumsg));
menu->AddItem(submenu);
BMenuItem *item = submenu->ItemAt(gDifficulty);
if (item)
item->SetMarked(true);
submenu = new BMenu(B_TRANSLATE("Theme"));
for (int32 i = 0; i < gGameStyle->CountStyles(); i++)
{
menumsg = new BMessage(M_SET_THEME);
menumsg->AddString("name",gGameStyle->StyleAt(i));
submenu->AddItem(new BMenuItem(TranslateWellKnownThemes(gGameStyle->StyleAt(i)),menumsg));
}
menu->AddItem(submenu);
submenu->SetRadioMode(true);
item = submenu->FindItem(TranslateWellKnownThemes(gGameStyle->StyleName()));
if (item)
item->SetMarked(true);
menu->AddSeparatorItem();
item = new BMenuItem(B_TRANSLATE("Sound effects"),new BMessage(M_TOGGLE_SOUNDS));
menu->AddItem(item);
item->SetMarked(gPlaySounds);
fMenuBar->AddItem(menu);
top->AddChild(fMenuBar);
fCounterView = new CounterView();
fCounterView->MoveTo(10,fMenuBar->Frame().bottom + 10);
top->AddChild(fCounterView);
r = gGameStyle->SmileyUp()->Bounds();
fSmileyButton = new BitmapButton(r,"smiley",gGameStyle->SmileyUp(),
gGameStyle->SmileyDown(), new BMessage(M_NEW_GAME),false,
B_FOLLOW_TOP | B_FOLLOW_H_CENTER);
top->AddChild(fSmileyButton);
fTimerView = new TimerView();
fTimerView->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
top->AddChild(fTimerView);
fFieldView = new FieldView(gDifficulty);
top->AddChild(fFieldView);
fFieldView->MakeFocus(true);
fCounterView->SetCount(fFieldView->MineCount());
ResetLayout();
AddCommonFilter(new SpaceBarFilter(M_NEW_GAME));
}
void
TFilePanel::Init(const BMessage*)
{
BRect windRect(Bounds());
AddChild(fBackView = new BackgroundView(windRect));
// add poseview menu bar
fMenuBar = new BMenuBar(BRect(0, 0, windRect.Width(), 1), "MenuBar");
fMenuBar->SetBorder(B_BORDER_FRAME);
fBackView->AddChild(fMenuBar);
AddMenus();
AddContextMenus();
FavoritesMenu* favorites = new FavoritesMenu(B_TRANSLATE("Favorites"),
new BMessage(kSwitchDirectory), new BMessage(B_REFS_RECEIVED),
BMessenger(this), IsSavePanel(), fPoseView->RefFilter());
favorites->AddItem(new BMenuItem(B_TRANSLATE("Add current folder"),
new BMessage(kAddCurrentDir)));
favorites->AddItem(new BMenuItem(
B_TRANSLATE("Edit favorites" B_UTF8_ELLIPSIS),
new BMessage(kEditFavorites)));
fMenuBar->AddItem(favorites);
// configure menus
BMenuItem* item = fMenuBar->FindItem(B_TRANSLATE("Window"));
if (item) {
fMenuBar->RemoveItem(item);
delete item;
}
item = fMenuBar->FindItem(B_TRANSLATE("File"));
if (item) {
BMenu* menu = item->Submenu();
if (menu) {
item = menu->FindItem(kOpenSelection);
if (item && menu->RemoveItem(item))
delete item;
item = menu->FindItem(kDuplicateSelection);
if (item && menu->RemoveItem(item))
delete item;
// remove add-ons menu, identifier menu, separator
item = menu->FindItem(B_TRANSLATE("Add-ons"));
if (item) {
int32 index = menu->IndexOf(item);
delete menu->RemoveItem(index);
delete menu->RemoveItem(--index);
delete menu->RemoveItem(--index);
}
// remove separator
item = menu->FindItem(B_CUT);
if (item) {
item = menu->ItemAt(menu->IndexOf(item)-1);
if (item && menu->RemoveItem(item))
delete item;
}
}
}
// add directory menu and menufield
fDirMenu = new BDirMenu(0, this, kSwitchDirectory, "refs");
font_height ht;
be_plain_font->GetHeight(&ht);
float f_height = ht.ascent + ht.descent + ht.leading;
BRect rect;
rect.top = fMenuBar->Bounds().Height() + 8;
rect.left = windRect.left + 8;
rect.right = rect.left + 300;
rect.bottom = rect.top + (f_height > 22 ? f_height : 22);
fDirMenuField = new BMenuField(rect, "DirMenuField", "", fDirMenu);
fDirMenuField->MenuBar()->SetFont(be_plain_font);
fDirMenuField->SetDivider(0);
fDirMenuField->MenuBar()->SetMaxContentWidth(rect.Width() - 26.0f);
// Make room for the icon
fDirMenuField->MenuBar()->RemoveItem((int32)0);
fDirMenu->SetMenuBar(fDirMenuField->MenuBar());
// the above is a weird call from BDirMenu
// ToDo: clean up
BEntry entry(TargetModel()->EntryRef());
if (entry.InitCheck() == B_OK)
fDirMenu->Populate(&entry, 0, true, true, false, true);
else
fDirMenu->Populate(0, 0, true, true, false, true);
fBackView->AddChild(fDirMenuField);
// add file name text view
if (fIsSavePanel) {
BRect rect(windRect);
rect.top = rect.bottom - 35;
rect.left = 8;
rect.right = rect.left + 170;
rect.bottom = rect.top + 13;
fTextControl = new BTextControl(rect, "text view",
B_TRANSLATE("save text"), "", NULL,
B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
DisallowMetaKeys(fTextControl->TextView());
DisallowFilenameKeys(fTextControl->TextView());
fBackView->AddChild(fTextControl);
fTextControl->SetDivider(0.0f);
fTextControl->TextView()->SetMaxBytes(B_FILE_NAME_LENGTH - 1);
fButtonText.SetTo(B_TRANSLATE("Save"));
} else
fButtonText.SetTo(B_TRANSLATE("Open"));
rect = windRect;
rect.OffsetTo(10, fDirMenuField->Frame().bottom + 10);
rect.bottom = windRect.bottom - 60;
rect.right -= B_V_SCROLL_BAR_WIDTH + 20;
// re-parent the poseview to our backview
// ToDo:
// This is terrible, fix it up
PoseView()->RemoveSelf();
if (fIsSavePanel)
fBackView->AddChild(PoseView(), fTextControl);
else
fBackView->AddChild(PoseView());
PoseView()->MoveTo(rect.LeftTop());
PoseView()->ResizeTo(rect.Width(), rect.Height());
PoseView()->AddScrollBars();
PoseView()->SetDragEnabled(false);
PoseView()->SetDropEnabled(false);
PoseView()->SetSelectionHandler(this);
PoseView()->SetSelectionChangedHook(true);
PoseView()->DisableSaveLocation();
PoseView()->VScrollBar()->MoveBy(0, -1);
PoseView()->VScrollBar()->ResizeBy(0, 1);
AddShortcut('W', B_COMMAND_KEY, new BMessage(kCancelButton));
AddShortcut('H', B_COMMAND_KEY, new BMessage(kSwitchToHome));
AddShortcut('A', B_COMMAND_KEY | B_SHIFT_KEY,
new BMessage(kShowSelectionWindow));
AddShortcut('A', B_COMMAND_KEY, new BMessage(B_SELECT_ALL), PoseView());
AddShortcut('S', B_COMMAND_KEY, new BMessage(kInvertSelection),
PoseView());
AddShortcut('Y', B_COMMAND_KEY, new BMessage(kResizeToFit), PoseView());
AddShortcut(B_DOWN_ARROW, B_COMMAND_KEY, new BMessage(kOpenDir));
AddShortcut(B_DOWN_ARROW, B_COMMAND_KEY | B_OPTION_KEY,
new BMessage(kOpenDir));
AddShortcut(B_UP_ARROW, B_COMMAND_KEY, new BMessage(kOpenParentDir));
AddShortcut(B_UP_ARROW, B_COMMAND_KEY | B_OPTION_KEY,
new BMessage(kOpenParentDir));
// New code to make buttons font sensitive
rect = windRect;
rect.top = rect.bottom - 35;
rect.bottom -= 10;
rect.right -= 25;
float default_width
= be_plain_font->StringWidth(fButtonText.String()) + 20;
rect.left = default_width > 75
? rect.right - default_width : rect.right - 75;
BButton* default_button = new BButton(rect, "default button",
fButtonText.String(), new BMessage(kDefaultButton),
B_FOLLOW_RIGHT + B_FOLLOW_BOTTOM);
fBackView->AddChild(default_button);
rect.right = rect.left -= 10;
float cancel_width
= be_plain_font->StringWidth(B_TRANSLATE("Cancel")) + 20;
rect.left = cancel_width > 75
? rect.right - cancel_width : rect.right - 75;
BButton* cancel_button = new BButton(rect, "cancel button",
B_TRANSLATE("Cancel"), new BMessage(kCancelButton),
B_FOLLOW_RIGHT + B_FOLLOW_BOTTOM);
fBackView->AddChild(cancel_button);
if (!fIsSavePanel)
default_button->SetEnabled(false);
default_button->MakeDefault(true);
RestoreState();
PoseView()->ScrollTo(B_ORIGIN);
PoseView()->UpdateScrollRange();
PoseView()->ScrollTo(B_ORIGIN);
if (fTextControl) {
fTextControl->MakeFocus();
fTextControl->TextView()->SelectAll();
} else
PoseView()->MakeFocus();
app_info info;
BString title;
if (be_app->GetAppInfo(&info) == B_OK) {
if (!gLocalizedNamePreferred
|| BLocaleRoster::Default()->GetLocalizedFileName(
title, info.ref, false) != B_OK)
title = info.ref.name;
title << ": ";
}
title << fButtonText; // Open or Save
SetTitle(title.String());
SetSizeLimits(370, 10000, 200, 10000);
}
void
SCMImportWindow::SetProvider(SCMProjectImporter *importer)
{
if (importer && !fProvider)
{
fSCMField->SetEnabled(true);
fProjectBox->SetEnabled(true);
fAnonymousBox->SetEnabled(true);
fUserNameBox->SetEnabled(true);
fRepository->SetEnabled(true);
fCommandView->MakeEditable(false);
fOK->SetEnabled(false);
fProjectBox->MakeFocus(true);
fProvider = importer;
UpdateCommand();
}
else if (!importer && fProvider)
{
fSCMField->SetEnabled(false);
fProjectBox->SetEnabled(false);
fAnonymousBox->SetEnabled(false);
fUserNameBox->SetEnabled(false);
fRepository->SetEnabled(false);
fCommandView->MakeEditable(true);
fCommandView->SetText("");
fCommandView->MakeFocus(true);
fOK->SetEnabled(true);
}
fProvider = importer;
if (fProvider)
{
BMenu *menu = fSCMField->Menu();
BMenuItem *item;
item = menu->FindItem("Mercurial");
if (item)
item->SetEnabled(fProvider->SupportsSCM(SCM_HG));
item = menu->FindItem("Git");
if (item)
item->SetEnabled(fProvider->SupportsSCM(SCM_GIT));
item = menu->FindItem("Subversion");
if (item)
item->SetEnabled(fProvider->SupportsSCM(SCM_SVN));
item = menu->FindMarked();
if (!item->IsEnabled())
{
item->SetMarked(false);
for (int32 i = 0; i < menu->CountItems(); i++)
if (menu->ItemAt(i)->IsEnabled())
{
menu->ItemAt(i)->SetMarked(true);
break;
}
}
}
UpdateCommand();
}
MainWindow::MainWindow(void)
: BWindow(BRect(200,200,800,750), B_TRANSLATE_SYSTEM_NAME("Slayer"), B_TITLED_WINDOW, 0)
{
slayer->mainWindow = this;
refreshThread = NULL;
if (Lock()) {
teamView = new TeamListView("MainTeamList");
// Menü
BMenuBar* menuBar = new BMenuBar("MenuBar");
BMenu* menu;
menu = new BMenu(B_TRANSLATE_SYSTEM_NAME("Slayer"));
menuBar->AddItem(menu);
menu->AddItem(new BMenuItem(B_TRANSLATE("About Slayer..."), new BMessage(B_ABOUT_REQUESTED)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Settings..."), new BMessage(IE_MAINWINDOW_MAINMENU_WINDOWS_SETTINGS)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"), new BMessage(B_QUIT_REQUESTED), 'Q'));
menu = new BMenu(B_TRANSLATE("Action"));
menu->AddItem(new BMenuItem(B_TRANSLATE("Kill"), new BMessage(IE_MAINWINDOW_MAINKILL), 'K'));
menu->AddItem(new BMenuItem(B_TRANSLATE("Suspend"), new BMessage(IE_MAINWINDOW_MAINSUSPEND), 'S'));
menu->AddItem(new BMenuItem(B_TRANSLATE("Resume"), new BMessage(IE_MAINWINDOW_MAINRESUME), 'R'));
menu->AddSeparatorItem();
priorityMenu = new PriorityMenu(teamView);
menu->AddItem(priorityMenu);
priorityMenu->BuildMenu();
menuBar->AddItem(menu);
fToolBar = new BToolBar(B_HORIZONTAL);
BGroupLayout *topBox = BLayoutBuilder::Group<>(this,B_VERTICAL, 0)
.Add(menuBar)
.Add(fToolBar)
.AddGroup(B_VERTICAL)
.SetInsets(B_USE_WINDOW_INSETS, 0, B_USE_WINDOW_INSETS, B_USE_WINDOW_INSETS)
.Add(teamView);
teamView->LoadState(&(slayer->options.columnsState));
team_items_list = 0;
team_amount = 0;
iteration = 0;
refreshThread = new RefreshThread();
UpdateTeams();
if (slayer->options.wind_rect.IsValid()) {
MoveTo(slayer->options.wind_rect.left,
slayer->options.wind_rect.top);
ResizeTo(slayer->options.wind_rect.Width(),
slayer->options.wind_rect.Height());
}
minimized = false;
if (slayer->options.workspace_activation == Options::all_workspaces)
SetWorkspaces(B_ALL_WORKSPACES);
else if (slayer->options.workspace_activation == Options::saved_workspace)
SetWorkspaces(0x1UL << (slayer->options.workspaces -1 ));
if (slayer->options.wind_minimized)
Minimize(true);
// Quitting has to be disabled if docked
if (slayer->docked) {
BMenu *menu = (BMenu *)FindView("MainMenu");
BMenuItem *item = menu->FindItem(IE_MAINWINDOW_MAINMENU_FILE_QUIT);
item->SetEnabled(false);
}
fToolBar->AddAction(new BMessage(IE_MAINWINDOW_MAINKILL),this,
ResourceVectorToBitmap("KILL"),B_TRANSLATE("Kill"),"",false);
fToolBar->AddAction(new BMessage(IE_MAINWINDOW_MAINSUSPEND),this,
ResourceVectorToBitmap("SUSPEND"),B_TRANSLATE("Suspend"),"",false);
fToolBar->AddAction(new BMessage(IE_MAINWINDOW_MAINRESUME),this,
ResourceVectorToBitmap("RESUME"),B_TRANSLATE("Resume"),"",false);
fToolBar->AddAction(new BMessage(IE_MAINWINDOW_MAINUPDATE),this,
ResourceVectorToBitmap("FORCED_RELOAD"),B_TRANSLATE("Forced reload"),"",false);
fToolBar->GetLayout()->AddItem(BSpaceLayoutItem::CreateGlue());
if (teamView != NULL)
teamView->MakeFocus();
SetButtonState();
refreshThread->Go();
Unlock();
}
Show();
}
void
HWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case M_OTHER_MESSAGE:
{
BMenuField* menufield
= dynamic_cast<BMenuField*>(FindView("filemenu"));
if (menufield == NULL)
return;
BMenu* menu = menufield->Menu();
HEventRow* row = (HEventRow*)fEventList->CurrentSelection();
if (row != NULL) {
BPath path(row->Path());
if (path.InitCheck() != B_OK) {
BMenuItem* item = menu->FindItem(B_TRANSLATE("<none>"));
if (item != NULL)
item->SetMarked(true);
} else {
BMenuItem* item = menu->FindItem(path.Leaf());
if (item != NULL)
item->SetMarked(true);
}
}
fFilePanel->Show();
break;
}
case B_SIMPLE_DATA:
case B_REFS_RECEIVED:
{
entry_ref ref;
HEventRow* row = (HEventRow*)fEventList->CurrentSelection();
if (message->FindRef("refs", &ref) == B_OK && row != NULL) {
BMenuField* menufield
= dynamic_cast<BMenuField*>(FindView("filemenu"));
if (menufield == NULL)
return;
BMenu* menu = menufield->Menu();
// check audio file
BNode node(&ref);
BNodeInfo ninfo(&node);
char type[B_MIME_TYPE_LENGTH + 1];
ninfo.GetType(type);
BMimeType mtype(type);
BMimeType superType;
mtype.GetSupertype(&superType);
if (superType.Type() == NULL
|| strcmp(superType.Type(), "audio") != 0) {
beep();
BAlert* alert = new BAlert("",
B_TRANSLATE("This is not an audio file."),
B_TRANSLATE("OK"), NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
break;
}
// add file item
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
BPath path(&ref);
msg->AddRef("refs", &ref);
BMenuItem* menuitem = menu->FindItem(path.Leaf());
if (menuitem == NULL)
menu->AddItem(menuitem = new BMenuItem(path.Leaf(), msg), 0);
// refresh item
fEventList->SetPath(BPath(&ref).Path());
// check file menu
if (menuitem != NULL)
menuitem->SetMarked(true);
}
break;
}
case M_PLAY_MESSAGE:
{
HEventRow* row = (HEventRow*)fEventList->CurrentSelection();
if (row != NULL) {
const char* path = row->Path();
if (path != NULL) {
entry_ref ref;
::get_ref_for_path(path, &ref);
delete fPlayer;
fPlayer = new BFileGameSound(&ref, false);
fPlayer->StartPlaying();
}
}
break;
}
case M_STOP_MESSAGE:
{
if (fPlayer == NULL)
break;
if (fPlayer->IsPlaying()) {
fPlayer->StopPlaying();
delete fPlayer;
fPlayer = NULL;
}
break;
}
case M_EVENT_CHANGED:
{
const char* path;
BMenuField* menufield
= dynamic_cast<BMenuField*>(FindView("filemenu"));
if (menufield == NULL)
return;
BMenu* menu = menufield->Menu();
if (message->FindString("path", &path) == B_OK) {
BPath path(path);
if (path.InitCheck() != B_OK) {
BMenuItem* item = menu->FindItem(B_TRANSLATE("<none>"));
if (item != NULL)
item->SetMarked(true);
} else {
BMenuItem* item = menu->FindItem(path.Leaf());
if (item != NULL)
item->SetMarked(true);
}
}
break;
}
case M_ITEM_MESSAGE:
{
entry_ref ref;
if (message->FindRef("refs", &ref) == B_OK)
fEventList->SetPath(BPath(&ref).Path());
break;
}
case M_NONE_MESSAGE:
{
fEventList->SetPath(NULL);
break;
}
default:
BWindow::MessageReceived(message);
}
}
void TCueSheetWindow::AdjustWindowsMenu()
{
// Set up string buffers
bool retVal;
char* menuStr = (char*)malloc( sizeof(char) * 256);
// Get application
MuseumApp* theApp = static_cast<MuseumApp*>(be_app);
BMenu* theMenu = fAppMenu->GetWindowsMenu();
if (theMenu) {
// Stage Item
BMenuItem* stageItem = theMenu->FindItem(WINDOWS_STAGE_MSG);
if (stageItem) {
TStageWindow* stage = fStageWindow;
if (stage) {
stage->Lock();
if (stage->IsHidden())
retVal = GetString("WindowsMenuStrings", kWindowsShowStageItem, menuStr);
else
retVal = GetString("WindowsMenuStrings", kWindowsHideStageItem, menuStr);
stage->Unlock();
stageItem->SetLabel(menuStr);
} else {
retVal = GetString("WindowsMenuStrings", kWindowsShowStageItem, menuStr);
stageItem->SetLabel(menuStr);
}
}
// Browser Item
BMenuItem* browserItem = theMenu->FindItem(WINDOWS_BROWSER_MSG);
if (stageItem) {
TBrowserWindow* browser = theApp->GetBrowser();
if (browser) {
browser->Lock();
if (browser->IsHidden())
retVal = GetString("WindowsMenuStrings", kWindowsShowBrowserItem, menuStr);
else
retVal = GetString("WindowsMenuStrings", kWindowsHideBrowserItem, menuStr);
browser->Unlock();
browserItem->SetLabel(menuStr);
} else {
retVal = GetString("WindowsMenuStrings", kWindowsShowBrowserItem, menuStr);
browserItem->SetLabel(menuStr);
}
}
// Transport Item
BMenuItem* transportItem = theMenu->FindItem(WINDOWS_TRANSPORT_MSG);
if (transportItem) {
TTransportPalette* transport = theApp->GetTransport();
if (transport) {
transport->Lock();
if (transport->IsHidden())
retVal = GetString("WindowsMenuStrings", kWindowsShowTransportItem, menuStr);
else
retVal = GetString("WindowsMenuStrings", kWindowsHideTransportItem, menuStr);
transport->Unlock();
transportItem->SetLabel(menuStr);
} else {
retVal = GetString("WindowsMenuStrings", kWindowsShowTransportItem, menuStr);
transportItem->SetLabel(menuStr);
}
}
// Locator Item
BMenuItem* counterItem = theMenu->FindItem(WINDOWS_COUNTER_MSG);
if (counterItem) {
TTimePalette* time = theApp->GetTimePalette();
if (time) {
time->Lock();
if (time->IsHidden())
retVal = GetString("WindowsMenuStrings", kWindowsShowLocatorItem, menuStr);
else
retVal = GetString("WindowsMenuStrings", kWindowsHideLocatorItem, menuStr);
time->Unlock();
counterItem->SetLabel(menuStr);
} else {
retVal = GetString("WindowsMenuStrings", kWindowsShowLocatorItem, menuStr);
counterItem->SetLabel(menuStr);
}
}
// Media Cue Item
BMenuItem* mediaItem = theMenu->FindItem(WINDOWS_MEDIA_MSG);
if (mediaItem) {
TMediaCuePalette* mediaPalette = theApp->GetMediaPalette();
if (mediaPalette) {
mediaPalette->Lock();
if (mediaPalette->IsHidden())
retVal = GetString("WindowsMenuStrings", kWindowsShowMediaItem, menuStr);
else
retVal = GetString("WindowsMenuStrings", kWindowsHideMediaItem, menuStr);
mediaPalette->Unlock();
mediaItem->SetLabel(menuStr);
} else {
retVal = GetString("WindowsMenuStrings", kWindowsShowMediaItem, menuStr);
mediaItem->SetLabel(menuStr);
}
}
}
}
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);
}
float PBox::BuildGUI(BMessage viewTemplate, BMessage settings, BView *view) {
BMessage curr;
float yOffset = kEdgeOffset + kControlOffset;
float xOffset = 0;
const float kControlWidth = view->Bounds().Width() - (kEdgeOffset * 2);
BMessage postAdded;
for (int i=0; viewTemplate.FindMessage("setting",i,&curr) == B_OK; i++ ) {
char temp[512];
// get text etc from template
const char * name = curr.FindString("name");
const char * desc = curr.FindString("description");
const char * value = NULL;
int32 type = -1;
bool secret = false;
bool freeText = true;
bool multiLine = false;
BView *control = NULL;
BMenu *menu = NULL;
BMessage* enabling = NULL;
if ( name != NULL && strcmp(name,"app_sig") == 0 ) {
// skip app-sig setting
continue;
}
if (curr.FindInt32("type", &type) != B_OK) {
printf("Error getting type for %s, skipping\n", name);
continue;
};
switch (type) {
case B_STRING_TYPE: {
if (curr.FindString("valid_value")) {
// It's a "select one of these" setting
freeText = false;
menu = new BPopUpMenu(name);
// menu->SetDivider(be_plain_font->StringWidth(name) + 10);
for (int j = 0; curr.FindString("valid_value", j); j++) {
menu->AddItem(new BMenuItem(curr.FindString("valid_value", j),NULL));
};
value = NULL;
value = curr.FindString("default");
if (value && menu->FindItem(value)) menu->FindItem(value)->SetMarked(true);
value = settings.FindString(name);
if (value && menu->FindItem(value)) menu->FindItem(value)->SetMarked(true);
} else {
// It's a free-text setting
if (curr.FindBool("multi_line", &multiLine) != B_OK) multiLine = false;
value = settings.FindString(name);
if (!value) value = curr.FindString("default");
if (curr.FindBool("is_secret",&secret) != B_OK) secret = false;
}
} break;
case B_INT32_TYPE: {
if (curr.FindInt32("valid_value")) {
// It's a "select one of these" setting
freeText = false;
menu = new BPopUpMenu(name);
int32 v = 0;
for ( int j = 0; curr.FindInt32("valid_value",j,&v) == B_OK; j++ ) {
sprintf(temp,"%ld", v);
menu->AddItem(new BMenuItem(temp, NULL));
};
if ( curr.FindInt32("default",&v) == B_OK ) {
sprintf(temp,"%ld",v);
value = temp;
menu->FindItem(value)->SetMarked(true);
}
if ( settings.FindInt32(name,&v) == B_OK ) {
sprintf(temp,"%ld",v);
value = temp;
menu->FindItem(value)->SetMarked(true);
}
} else {
// It's a free-text (but number) setting
int32 v = 0;
if (settings.FindInt32(name,&v) == B_OK) {
sprintf(temp,"%ld",v);
value = temp;
} else if ( curr.FindInt32("default",&v) == B_OK ) {
sprintf(temp,"%ld",v);
value = temp;
}
if (curr.FindBool("is_secret",&secret) != B_OK) secret = false;
}
} break;
case B_BOOL_TYPE: {
bool active;
if (settings.FindBool(name, &active) != B_OK) {
if (curr.FindBool("default", &active) != B_OK) {
active = false;
};
};
for (int j = 0; curr.FindString("enable_control", j); j++) {
if(!enabling) enabling = new BMessage('enab');
enabling->AddString("enable_control",curr.FindString("enable_control",j) );
if(!active) postAdded.AddString("disable",curr.FindString("enable_control", j));
};
control = new BCheckBox(BRect(0, 0, kControlWidth, fFontHeight),
name, _T(desc), enabling);
if (active) ((BCheckBox*)control)->SetValue(B_CONTROL_ON);
} break;
default: {
continue;
};
};
if (!value) value = "";
if (!control) {
if (freeText) {
if (multiLine == false) {
control = new BTextControl(
BRect(0, 0, kControlWidth, fFontHeight), name,
_T(desc), value, NULL);
if (secret) {
((BTextControl *)control)->TextView()->HideTyping(true);
((BTextControl *)control)->SetText(_T(value));
};
((BTextControl *)control)->SetDivider(kDividerWidth);
} else
{
BRect rect;
BRect textRect;
if (desc) //andrea: add description only if available.
{
BRect labelRect(0, 0, kDividerWidth, fFontHeight);
BStringView *label = new BStringView(labelRect, "NA", _T(desc),
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
view->AddChild(label);
label->MoveTo(kEdgeOffset, yOffset);
rect = BRect(0, 0, kControlWidth - kDividerWidth, fFontHeight * 4);
rect.right -= B_V_SCROLL_BAR_WIDTH + kEdgeOffset + kControlOffset;
xOffset = kEdgeOffset + kDividerWidth;
}
else
{
rect = BRect(0, 0, kControlWidth, fFontHeight * 4);
rect.right -= B_V_SCROLL_BAR_WIDTH + kControlOffset;
xOffset = 0;
}
textRect = rect;
textRect.InsetBy(kEdgeOffset, kEdgeOffset);
textRect.OffsetTo(1.0, 1.0);
BTextView *textView = new BTextView(rect, name, textRect,
B_FOLLOW_ALL_SIDES, B_WILL_DRAW);
control = new BScrollView("NA", textView, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_NAVIGABLE, false, true);
textView->SetText(_T(value));
};
} else {
control = new BMenuField(BRect(0, 0, kControlWidth, fFontHeight),
name, _T(desc), menu);
float size=kDividerWidth;
if(control->StringWidth(_T(desc)) > kDividerWidth)
size=control->StringWidth(_T(desc)) + 20;
((BMenuField *)control)->SetDivider(size);
};
};
view->AddChild(control);
if(enabling)
((BCheckBox*)control)->SetTarget(this);
float h, w = 0;
control->GetPreferredSize(&w, &h);
if (h < control->Bounds().Height())
h = control->Bounds().Height();
control->MoveTo(kEdgeOffset + xOffset, yOffset);
yOffset += kControlOffset + h ;
xOffset = 0;
};
for (int j = 0; postAdded.FindString("disable", j); j++)
{
const char* name=postAdded.FindString("disable", j);
BView* viewz=view->FindView(name);
if(viewz)
((BControl*)viewz)->SetEnabled(false);
}
//if ( yOffset < view->Bounds().Height() )
// yOffset = view->Bounds().Height();
return yOffset;//view->ResizeTo( view->Bounds().Width(), yOffset
}
void TCueSheetWindow::AdjustCueSheetMenu()
{
BMenu* theMenu = fAppMenu->GetCueSheetMenu();
if (theMenu) {
// Setup Item
BMenuItem* setupItem = theMenu->FindItem(CUE_SETUP_MSG);
if (setupItem)
;
// Time Base Item
BMenuItem* timeBaseItem = theMenu->FindItem(CUE_TIMEBASE_MSG);
if (timeBaseItem)
;
// Zoom In Item
BMenuItem* zoomInItem = theMenu->FindItem(CUE_ZOOMIN_MSG);
if (zoomInItem)
;
// Zoom Out Item
BMenuItem* zoomOutItem = theMenu->FindItem(CUE_ZOOMOUT_MSG);
if (zoomOutItem)
;
// Show Durations Item
// Enable if there are any cues in the cue sheet
BMenuItem* showDurationsItem = theMenu->FindItem(CUE_SHOWDURATIONS_MSG);
if (showDurationsItem) {
// Enable this item if there are any cues to be selected
showDurationsItem->SetEnabled( fCueSheetView->HasCues() );
}
// Show Stop Time Item
BMenuItem* showStopTimeItem = theMenu->FindItem(CUE_SHOWSTOPTIMES_MSG);
if (showStopTimeItem) {
// Enable this item if there are any cues to be selected
showStopTimeItem->SetEnabled( fCueSheetView->HasCues() );
}
// Insert Channels Item
BMenuItem* insertItem = theMenu->FindItem(CUE_INSERTCHANNELS_MSG);
if (insertItem)
;
// Delete Channels Item
BMenuItem* deleteItem = theMenu->FindItem(CUE_DELETECHANNELS_MSG);
if (deleteItem) {
// If we only have one channel, disable this item
if (fCueSheetView->GetTotalChannels() > 1)
deleteItem->SetEnabled(true);
else
deleteItem->SetEnabled(false);
}
// Insert Time Item
BMenuItem* insertTimeItem = theMenu->FindItem(CUE_INSERTTIME_MSG);
if (insertTimeItem) {
insertTimeItem->SetEnabled(false);
}
// Align Start Item
BMenuItem* startItem = theMenu->FindItem(CUE_ALIGNSTART_MSG);
if (startItem) {
// A cue in two or more distinct channels must be selected for this
// command to be enable
if ( fCueSheetView->HasMultipleCueChannelsSelected() )
startItem->SetEnabled(true);
else
startItem->SetEnabled(false);
}
// Align End Item
BMenuItem* endItem = theMenu->FindItem(CUE_ALIGNEND_MSG);
if (endItem) {
// A cue in two or more distinct channels must be selected for this
// command to be enable
if ( fCueSheetView->HasMultipleCueChannelsSelected() )
endItem->SetEnabled(true);
else
endItem->SetEnabled(false);
}
// Collapse Item
BMenuItem* collapseItem = theMenu->FindItem(CUE_COLLAPSEALL_MSG);
if (collapseItem)
;
// Jump To Item
BMenuItem* jumpToItem = theMenu->FindItem(CUE_JUMPTO_MSG);
if (jumpToItem)
;
}
}
MacWindow::MacWindow(BRect frame, const BeOS_monitor_desc& monitor)
: BDirectWindow(frame, GetString(STR_WINDOW_TITLE), B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_CLOSABLE | B_NOT_ZOOMABLE)
, monitor(monitor)
{
supports_direct_mode = SupportsWindowMode();
// Move window to right position
Lock();
MoveTo(80, 60);
// Allocate bitmap and Mac frame buffer
uint32 x = frame.IntegerWidth() + 1;
uint32 y = frame.IntegerHeight() + 1;
int fbsize = x * y;
const video_mode &mode = monitor.get_current_mode();
switch (mode.depth) {
case VDEPTH_1BIT:
fprintf(stderr, "1BIT SCREEN CREATED");
the_bitmap = new BBitmap(frame, B_GRAY1);
fbsize /= 8;
break;
case VDEPTH_8BIT:
fprintf(stderr, "8BIT SCREEN CREATED");
the_bitmap = new BBitmap(frame, B_CMAP8);
break;
case VDEPTH_32BIT:
fprintf(stderr, "32BIT SCREEN CREATED");
the_bitmap = new BBitmap(frame, B_RGB32_BIG);
fbsize *= 4;
break;
default:
fprintf(stderr, "width: %d", 1 << mode.depth);
debugger("OOPS");
}
#if REAL_ADDRESSING
monitor.set_mac_frame_base((uint32)the_bitmap->Bits());
#else
monitor.set_mac_frame_base(MacFrameBaseMac);
#endif
#if !REAL_ADDRESSING
// Set variables for UAE memory mapping
MacFrameBaseHost = (uint8*)the_bitmap->Bits();
MacFrameSize = fbsize;
MacFrameLayout = FLAYOUT_DIRECT;
#endif
// Create bitmap view
main_view = new BitmapView(frame, the_bitmap);
AddChild(main_view);
main_view->MakeFocus();
// Read frame skip prefs
frame_skip = PrefsFindInt32("frameskip");
if (frame_skip == 0)
frame_skip = 1;
// Set up menus
BRect bounds = Bounds();
bounds.OffsetBy(0, bounds.IntegerHeight() + 1);
BMenuItem *item;
BMenuBar *bar = new BMenuBar(bounds, "menu");
BMenu *menu = new BMenu(GetString(STR_WINDOW_MENU));
menu->AddItem(new BMenuItem(GetString(STR_WINDOW_ITEM_ABOUT), new BMessage(MSG_ABOUT_REQUESTED)));
menu->AddItem(new BSeparatorItem);
BMenu *submenu = new BMenu(GetString(STR_WINDOW_ITEM_REFRESH));
submenu->AddItem(new BMenuItem(GetString(STR_REF_5HZ_LAB), new BMessage(MSG_REF_5HZ)));
submenu->AddItem(new BMenuItem(GetString(STR_REF_7_5HZ_LAB), new BMessage(MSG_REF_7_5HZ)));
submenu->AddItem(new BMenuItem(GetString(STR_REF_10HZ_LAB), new BMessage(MSG_REF_10HZ)));
submenu->AddItem(new BMenuItem(GetString(STR_REF_15HZ_LAB), new BMessage(MSG_REF_15HZ)));
submenu->AddItem(new BMenuItem(GetString(STR_REF_30HZ_LAB), new BMessage(MSG_REF_30HZ)));
submenu->AddItem(new BMenuItem(GetString(STR_REF_60HZ_LAB), new BMessage(MSG_REF_60HZ)));
submenu->SetRadioMode(true);
if (frame_skip == 12) {
if ((item = submenu->FindItem(GetString(STR_REF_5HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (frame_skip == 8) {
if ((item = submenu->FindItem(GetString(STR_REF_7_5HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (frame_skip == 6) {
if ((item = submenu->FindItem(GetString(STR_REF_10HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (frame_skip == 4) {
if ((item = submenu->FindItem(GetString(STR_REF_15HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (frame_skip == 2) {
if ((item = submenu->FindItem(GetString(STR_REF_30HZ_LAB))) != NULL)
item->SetMarked(true);
} else if (frame_skip == 1) {
if ((item = submenu->FindItem(GetString(STR_REF_60HZ_LAB))) != NULL)
item->SetMarked(true);
}
menu->AddItem(submenu);
submenu = new BMenu(GetString(STR_WINDOW_ITEM_MOUNT));
SysCreateVolumeMenu(submenu, MSG_MOUNT);
menu->AddItem(submenu);
#if DEBUGGER_AVAILABLE
menu->AddItem(new BMenuItem("Debugger", new BMessage(MSG_DEBUGGER)));
#endif
bar->AddItem(menu);
AddChild(bar);
SetKeyMenuBar(bar);
int mbar_height = bar->Frame().IntegerHeight() + 1;
// Resize window to fit menu bar
ResizeBy(0, mbar_height);
// Set absolute mouse mode and get scroll lock state
ADBSetRelMouseMode(false);
mouse_in_view = true;
old_scroll_lock_state = modifiers() & B_SCROLL_LOCK;
if (old_scroll_lock_state)
SetTitle(GetString(STR_WINDOW_TITLE_FROZEN));
else
SetTitle(GetString(STR_WINDOW_TITLE));
// Keep window aligned to 8-byte frame buffer boundaries for faster blitting
SetWindowAlignment(B_BYTE_ALIGNMENT, 8);
// Create drawing semaphore (for direct mode)
drawing_sem = create_sem(0, "direct frame buffer access");
// Start 60Hz interrupt
tick_thread_active = true;
tick_thread = spawn_thread(tick_func, "Window Redraw", B_DISPLAY_PRIORITY, this);
resume_thread(tick_thread);
// Add filter for keyboard and mouse events
BMessageFilter *filter = new BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE, filter_func);
main_view->AddFilter(filter);
// Show window
Unlock();
Show();
Sync();
}
