/***********************************************************
* 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);
}
// ------------------------------------------------------------- RHTML_Preferences_Win - RHTMLPreferencesWin -
RHTMLPreferencesWin::RHTMLPreferencesWin(BRect fRect,BWindow *parent): BWindow(fRect,fOptions->GetLocaleString("Preferences_Window","Preferences"),B_FLOATING_WINDOW,B_UNTYPED_WINDOW)
{
fParent=parent;
IsQuit=false;
fList = new BOutlineListView(BRect(0,0,150,Bounds().bottom),"List",B_SINGLE_SELECTION_LIST,B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
BView *view1= new BView(BRect(151,0,151,Bounds().bottom),"view",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fView=new BView(BRect(152,0,Bounds().right,Bounds().bottom),"view",B_FOLLOW_ALL,B_WILL_DRAW);
AddChild(fList);
AddChild(view1);
AddChild(fView);
fView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view1->SetViewColor(184,184,184,0);
fList->SetSelectionMessage(new BMessage('LIST'));
JViewDb=5;
fJView = (BView**) calloc(JViewDb,sizeof(BView));
// - Create Languages
fList->AddItem(new BStringItem(fOptions->GetLocaleString("Preferences_Window_List","Languages")));
fJView[0] = new BView(fView->Bounds(),"LangView",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fJView[0]->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fView->AddChild(fJView[0]);
fLangMenu = new BMenu(fOptions->Locale[fOptions->CurrentLocale]->Lang.String());
fLangMenu->SetLabelFromMarked(true);
fLangMenu->SetRadioMode(true);
for (int32 i=0;i<(int32)fOptions->LocaleDb;i++)
{
BMessage* msg = new BMessage('LANG');
msg->AddInt32("Lang",i);
BMenuItem *item;
fLangMenu->AddItem(item=new BMenuItem(fOptions->Locale[i]->Lang.String(),msg));
item->SetTarget(this);
}
fLanguages= new BMenuField(BRect(10,10,250,30),"LanguagesMenu",fOptions->GetLocaleString("Preferences_Window_Languages","Languages"),fLangMenu);
fJView[0]->AddChild(fLanguages);
fView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fStrView1 = new BStringView(BRect(10,50,250,100),"strview1","Language:");
fJView[0]->AddChild(fStrView1);
fStrView2 = new BStringView(BRect(10,50,250,120),"strview1","");
fJView[0]->AddChild(fStrView2);
fStrView3 = new BStringView(BRect(10,50,250,150),"strview1","Author:");
fJView[0]->AddChild(fStrView3);
author = new URLView( BRect(0,50,250,170),"author","","");
fJView[0]->AddChild(author);
fStrView4 = new BStringView(BRect(10,50,250,200),"strview4","Language version:");
fJView[0]->AddChild(fStrView4);
fStrView5 = new BStringView(BRect(10,50,300,220),"strview5","");
fJView[0]->AddChild(fStrView5);
fStrView6 = new BStringView(BRect(10,50,300,250),"strview6","Language create to:");
fJView[0]->AddChild(fStrView6);
fStrView7 = new BStringView(BRect(10,50,300,270),"strview7","");
fJView[0]->AddChild(fStrView7);
LSetAuthor();
// - Create FileTypes
fJView[1] = new BView(fView->Bounds(),"FTView",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fJView[1]->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fView->AddChild(fJView[1]);
// - Create FileTypes/Fonts
fFTFontsBox= new BBox(BRect(10,10,200,120));
fFTFontsBox->SetLabel(fOptions->GetLocaleString("Preferences_Window_FileTypes","Default font"));
fFTFontsBox->SetFont(new BFont(be_plain_font));
fJView[1]->AddChild(fFTFontsBox);
BString stmp;
stmp << (int32) fOptions->DefaultFont->Size();
BMenu *fSizeMenu = new BMenu(stmp.String());
fSizeMenu->SetRadioMode(false);
fSizeMenu->SetLabelFromMarked(true);
for (int32 o=8;o<15;o++)
{
BMessage *msg2;
msg2 = new BMessage('FTSZ');
msg2->AddInt32("font_size",o);
BString tmp;
tmp << o;
fSizeMenu->AddItem(new BMenuItem(tmp.String(),msg2));
}
fFTDFSize= new BMenuField(BRect(10,75,180,105),"Font Size",fOptions->GetLocaleString("Preferences_Window_FileTypes","Size"),fSizeMenu);
fFTDFSize->SetDivider(60);
fFTFontsBox->AddChild(fFTDFSize);
font_family fFamily;
font_style fStyle;
fOptions->DefaultFont->GetFamilyAndStyle(&fFamily,&fStyle);
fFTDFStyle= new BMenuField(BRect(10,45,180,75),"Font Style",fOptions->GetLocaleString("Preferences_Window_FileTypes","Style"),new BMenu("Style"));
fFTDFStyle->SetDivider(60);
fFTFontsBox->AddChild(fFTDFStyle);
FTSetFont(fFamily,fStyle);
BMenu *fMenu = new BMenu(fFamily);
fMenu->SetRadioMode(false);
fMenu->SetLabelFromMarked(true);
const int32 fontNum = count_font_families();
for(int32 i = 0; i < fontNum; i++)
{
get_font_family(i,&fFamily);
BMessage* msg = new BMessage('FTDF');
msg->AddString("font_family", fFamily);
fMenu->AddItem(new BMenuItem(fFamily,msg));
}
fFTDFont= new BMenuField(BRect(10,15,180,35),"Default font",fOptions->GetLocaleString("Preferences_Window_FileTypes","Font"),fMenu);
fFTDFont->SetDivider(60);
fFTFontsBox->AddChild(fFTDFont);
// - Create FileTypes/Extensions
fFTBox= new BBox(BRect(10,130,200,290));
fFTBox->SetLabel(fOptions->GetLocaleString("Preferences_Window_FileTypes","Extension"));
fFTBox->SetFont(new BFont(be_plain_font));
fJView[1]->AddChild(fFTBox);
BListItem *FTUitem;
fList->AddItem(FTUitem=new BStringItem(fOptions->GetLocaleString("Preferences_Window_List","Filetypes")));
fFTFTMenu = new BMenu(fOptions->FileTypes[0]->Name->String());
fFTFTMenu->SetLabelFromMarked(true);
fFTFTMenu->SetRadioMode(true);
for (int32 i=0;i<(int32)fOptions->FileTypesDb;i++)
{
BMessage* msg = new BMessage('FTFT');
msg->AddInt32("FileType",i);
BMenuItem *item;
fFTFTMenu->AddItem(item=new BMenuItem(fOptions->FileTypes[i]->Name->String(),msg));
item->SetTarget(this);
}
fFTFT= new BMenuField(BRect(10,15,180,35),"FileTypesMenu",fOptions->GetLocaleString("Preferences_Window_FileTypes","Filetype"),fFTFTMenu);
fFTFT->SetDivider(80);
fFTBox->AddChild(fFTFT);
fFTKit = new BListView(BRect(10,40,54,120),"KitList",B_SINGLE_SELECTION_LIST,B_FOLLOW_NONE,B_WILL_DRAW);
BScrollView *fScrollView = new BScrollView("List",fFTKit,B_FOLLOW_ALL_SIDES,B_WILL_DRAW, false, true,B_FANCY_BORDER);
fFTBox->AddChild(fScrollView);
fFTKit->TargetedByScrollView(fScrollView);
fFTKit->SetSelectionMessage(new BMessage('FTSL'));
fFTAddButton = new BButton(BRect(90,40,170,60),"Add",fOptions->GetLocaleString("Preferences_Window_FileTypes","Add"),new BMessage('FTAD'));
fFTEditButton = new BButton(BRect(90,80,170,100),"Edit",fOptions->GetLocaleString("Preferences_Window_FileTypes","Edit"),new BMessage('FTED'));
fFTRemoveButton = new BButton(BRect(90,120,170,140),"Remove",fOptions->GetLocaleString("Preferences_Window_FileTypes","Remove"),new BMessage('FTRM'));
fFTBox->AddChild(fFTAddButton);
fFTBox->AddChild(fFTEditButton);
fFTBox->AddChild(fFTRemoveButton);
fFTStrView = new BTextControl(BRect(5,130,70,150),"Név","","",new BMessage('FTST'));
fFTStrView->SetDivider(0);
fFTBox->AddChild(fFTStrView);
FTCreateKitList(0);
// - Create FileTypes - Highlighting
fList->AddUnder(new BStringItem(fOptions->GetLocaleString("Preferences_Window_List","Highlighting")), FTUitem);
fJView[2] = new BView(fView->Bounds(),"FTView",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fJView[2]->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fView->AddChild(fJView[2]);
// - FT
fFTHFileTypes=0;
fFTHFTBox= new BBox(BRect(10,10,320,260));
fFTHFTBox->SetLabel(fOptions->GetLocaleString("Preferences_Window_FileTypes","Highlighting"));
fFTHFTBox->SetFont(new BFont(be_plain_font));
fJView[2]->AddChild(fFTHFTBox);
fFTFTMenu = new BMenu(fOptions->FileTypes[0]->Name->String());
fFTFTMenu->SetLabelFromMarked(true);
fFTFTMenu->SetRadioMode(true);
for (int32 i=0;i<(int32)fOptions->FileTypesDb;i++)
{
BMessage* msg = new BMessage('FTHF');
msg->AddInt32("FileType",i);
BMenuItem *item;
fFTFTMenu->AddItem(item=new BMenuItem(fOptions->FileTypes[i]->Name->String(),msg));
item->SetTarget(this);
}
fFTHFT= new BMenuField(BRect(10,15,210,30),"FileTypesMenu",fOptions->GetLocaleString("Preferences_Window_FileTypes","Filetype"),fFTFTMenu);
fFTHFT->SetDivider(100);
fFTHFTBox->AddChild(fFTHFT);
fFTHFC= new BMenuField(BRect(10,40,210,65),"FileTypesMenu",fOptions->GetLocaleString("Preferences_Window_FileTypes","Syntax styles"),new BMenu(""));
fFTHFC->SetDivider(100);
fFTHFTBox->AddChild(fFTHFC);
// - Font
fFTHFontColor=0;
fFTHFontBox= new BBox(BRect(10,80,230,130));
fFTHFontBox->SetLabel(fOptions->GetLocaleString("Preferences_Window_FileTypes","Font"));
fFTHFontBox->SetFont(new BFont(be_plain_font));
fFTHFTBox->AddChild(fFTHFontBox);
fFTHStyle= new BMenuField(BRect(10,15,210,40),"Size",fOptions->GetLocaleString("Preferences_Window_FileTypes","Style"),new BMenu("Style"));
fFTHFontBox->AddChild(fFTHStyle);
// - Color
fFTHColorBox= new BBox(BRect(10,150,300,240));
fFTHColorBox->SetLabel(fOptions->GetLocaleString("Preferences_Window_FileTypes","Color"));
fFTHColorBox->SetFont(new BFont(be_plain_font));
fFTHFTBox->AddChild(fFTHColorBox);
fFTHCC = new BColorControl(BPoint(10,20),B_CELLS_32x8,1,"CC",new BMessage(R_FTH_Color_MSG));
fFTHColorBox->AddChild(fFTHCC);
// - Default Folder
fList->AddItem(new BStringItem(fOptions->GetLocaleString("Preferences_Window_List","Default Folder")));
fJView[3] = new BView(fView->Bounds(),"OpenSaveView",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fJView[3]->SetViewColor(216,216,216,0);
fView->AddChild(fJView[3]);
fDFDefaultFolder = new BTextControl(BRect(10,10,260,30),"DFDefaultFolder",fOptions->GetLocaleString("Preferences_Window_DefaultFolder","Default Folder"),fOptions->DefaultFolder.String(),new BMessage('DFFN'));
fDFDefaultFolder->SetDivider(100);
fJView[3]->AddChild(fDFDefaultFolder);
BButton *fDFButton = new BButton(BRect(270,8,330,30),"DFButton",fOptions->GetLocaleString("Preferences_Window_DefaultFolder","Browse"),new BMessage('DFBB'));
fJView[3]->AddChild(fDFButton);
fDFFilePanel = new BFilePanel(B_OPEN_PANEL,new BMessenger(this,this), NULL,
B_DIRECTORY_NODE, false,new BMessage('DFFP'));
fDFCheckBox = new BCheckBox(BRect(150,40,280,60),"DFCheckBox",fOptions->GetLocaleString("Preferences_Window_DefaultFolder","Only Start"),new BMessage('DFCK'));
fJView[3]->AddChild(fDFCheckBox);
fDFCheckBox->SetValue(fOptions->DFOnlyStart);
// - Advanced Prefs
fList->AddItem(new BStringItem(fOptions->GetLocaleString("Preferences_Window_List","Advanced preferences")));
fJView[4] = new BView(fView->Bounds(),"AdvancedPrefs",B_FOLLOW_TOP_BOTTOM,B_WILL_DRAW);
fJView[4]->SetViewColor(216,216,216,0);
fView->AddChild(fJView[4]);
fAPSlider = new BSlider(BRect(10,10,330,50),"slider",fOptions->GetLocaleString("Preferences_Window_AdvancedPrefs","Parameter-Menu reaction time"),new BMessage('APRT'), 0, 1000);
fAPSlider->SetLimitLabels("0ms", "1000ms");
fAPSlider->SetValue(fOptions->ReakcioIdo);
fAPSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fAPSlider->SetHashMarkCount(5);
fJView[4]->AddChild(fAPSlider);
fAPTMSlider = new BSlider(BRect(10,100,330,150),"slider",fOptions->GetLocaleString("Preferences_Window_AdvancedPrefs","Tag-Menu reaction time"),new BMessage('APTM'), 0, 3000);
fAPTMSlider->SetLimitLabels("0ms", "3000ms");
fAPTMSlider->SetValue(fOptions->ReakcioIdo);
fAPTMSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fAPTMSlider->SetHashMarkCount(5);
fJView[4]->AddChild(fAPTMSlider);
// -
FTHSetFT(0);
fList->Select(0);
for (uint i=0;i<JViewDb;i++)fJView[i]->ResizeTo(0,0);
fJView[0]->ResizeTo(fView->Bounds().right,fView->Bounds().bottom);
}
// constructor
ObjectWindow::ObjectWindow(BRect frame, const char* name)
: BWindow(frame, name, B_DOCUMENT_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE)
{
BRect b(Bounds());
b.bottom = b.top + 8;
BMenuBar* menuBar = new BMenuBar(b, "menu bar");
AddChild(menuBar);
BMenu* menu = new BMenu("File");
menuBar->AddItem(menu);
menu->AddItem(new BMenu("Submenu"));
BMenuItem* menuItem = new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED),
'Q');
menu->AddItem(menuItem);
b = Bounds();
b.top = menuBar->Bounds().bottom + 1;
b.right = ceilf((b.left + b.right) / 2.0);
BBox* bg = new BBox(b, "bg box", B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW,
B_PLAIN_BORDER);
AddChild(bg);
bg->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
// object view occupies the right side of the window
b.left = b.right + 1.0;
b.right = Bounds().right - B_V_SCROLL_BAR_WIDTH;
b.bottom -= B_H_SCROLL_BAR_HEIGHT;
fObjectView = new ObjectView(b, "object view", B_FOLLOW_ALL,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE);
// wrap a scroll view around the object view
BScrollView* scrollView = new BScrollView("object scroller", fObjectView,
B_FOLLOW_ALL, 0, true, true, B_NO_BORDER);
if (BScrollBar* scrollBar = fObjectView->ScrollBar(B_VERTICAL)) {
scrollBar->SetRange(0.0, fObjectView->Bounds().Height());
scrollBar->SetProportion(0.5);
}
if (BScrollBar* scrollBar = fObjectView->ScrollBar(B_HORIZONTAL)) {
scrollBar->SetRange(0.0, fObjectView->Bounds().Width());
scrollBar->SetProportion(0.5);
}
AddChild(scrollView);
b = bg->Bounds();
// controls occupy the left side of the window
b.InsetBy(5.0, 5.0);
BBox* controlGroup = new BBox(b, "controls box",
B_FOLLOW_LEFT | B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW, B_FANCY_BORDER);
controlGroup->SetLabel("Controls");
bg->AddChild(controlGroup);
b = controlGroup->Bounds();
b.top += controlGroup->InnerFrame().top;
b.bottom = b.top + 25.0;
b.InsetBy(10.0, 10.0);
b.right = b.left + b.Width() / 2.0 - 5.0;
// new button
fNewB = new BButton(b, "new button", "New Object",
new BMessage(MSG_NEW_OBJECT));
controlGroup->AddChild(fNewB);
SetDefaultButton(fNewB);
// clear button
b.OffsetBy(0, fNewB->Bounds().Height() + 5.0);
fClearB = new BButton(b, "clear button", "Clear", new BMessage(MSG_CLEAR));
controlGroup->AddChild(fClearB);
// object type radio buttons
BMessage* message;
BRadioButton* radioButton;
b.OffsetBy(0, fClearB->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_LINE);
radioButton = new BRadioButton(b, "radio 1", "Line", message);
controlGroup->AddChild(radioButton);
radioButton->SetValue(B_CONTROL_ON);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_RECT);
radioButton = new BRadioButton(b, "radio 2", "Rect", message);
controlGroup->AddChild(radioButton);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_ROUND_RECT);
radioButton = new BRadioButton(b, "radio 3", "Round Rect", message);
controlGroup->AddChild(radioButton);
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
message = new BMessage(MSG_SET_OBJECT_TYPE);
message->AddInt32("type", OBJECT_ELLIPSE);
radioButton = new BRadioButton(b, "radio 4", "Ellipse", message);
controlGroup->AddChild(radioButton);
// drawing mode
BPopUpMenu* popupMenu = new BPopUpMenu("<pick>");
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_COPY);
popupMenu->AddItem(new BMenuItem("Copy", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_OVER);
popupMenu->AddItem(new BMenuItem("Over", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_INVERT);
popupMenu->AddItem(new BMenuItem("Invert", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_BLEND);
popupMenu->AddItem(new BMenuItem("Blend", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_SELECT);
popupMenu->AddItem(new BMenuItem("Select", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ERASE);
popupMenu->AddItem(new BMenuItem("Erase", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ADD);
popupMenu->AddItem(new BMenuItem("Add", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_SUBTRACT);
popupMenu->AddItem(new BMenuItem("Subtract", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_MIN);
popupMenu->AddItem(new BMenuItem("Min", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_MAX);
popupMenu->AddItem(new BMenuItem("Max", message));
message = new BMessage(MSG_SET_DRAWING_MODE);
message->AddInt32("mode", B_OP_ALPHA);
BMenuItem* item = new BMenuItem("Alpha", message);
item->SetMarked(true);
popupMenu->AddItem(item);
b.OffsetBy(0, radioButton->Bounds().Height() + 10.0);
fDrawingModeMF = new BMenuField(b, "drawing mode field", "Mode:",
popupMenu);
controlGroup->AddChild(fDrawingModeMF);
fDrawingModeMF->SetDivider(fDrawingModeMF->StringWidth(
fDrawingModeMF->Label()) + 10.0);
// color control
b.OffsetBy(0, fDrawingModeMF->Bounds().Height() + 10.0);
fColorControl = new BColorControl(b.LeftTop(), B_CELLS_16x16, 8,
"color control", new BMessage(MSG_SET_COLOR));
controlGroup->AddChild(fColorControl);
// alpha text control
b.OffsetBy(0, fColorControl-> Bounds().Height() + 5.0);
fAlphaTC = new BTextControl(b, "alpha text control", "Alpha:", "",
new BMessage(MSG_SET_COLOR));
controlGroup->AddChild(fAlphaTC);
// divide text controls the same
float mWidth = fDrawingModeMF->StringWidth(fDrawingModeMF->Label());
float aWidth = fAlphaTC->StringWidth(fAlphaTC->Label());
float width = max_c(mWidth, aWidth) + 20.0;
fDrawingModeMF->SetDivider(width);
fAlphaTC->SetDivider(width);
// fill check box
b.OffsetBy(0, fAlphaTC->Bounds().Height() + 5.0);
fFillCB = new BCheckBox(b, "fill check box", "Fill",
new BMessage(MSG_SET_FILL_OR_STROKE));
controlGroup->AddChild(fFillCB);
// pen size text control
b.OffsetBy(0, radioButton->Bounds().Height() + 5.0);
b.bottom = b.top + 10.0;//35;
fPenSizeS = new BSlider(b, "width slider", "Width:", NULL, 1, 100,
B_TRIANGLE_THUMB);
fPenSizeS->SetLimitLabels("1", "100");
fPenSizeS->SetModificationMessage(new BMessage(MSG_SET_PEN_SIZE));
fPenSizeS->SetHashMarks(B_HASH_MARKS_BOTTOM);
fPenSizeS->SetHashMarkCount(10);
controlGroup->AddChild(fPenSizeS);
// list view with objects
b = controlGroup->Bounds();
b.top += controlGroup->InnerFrame().top;
b.InsetBy(10.0, 10.0);
b.left = b.left + b.Width() / 2.0 + 6.0;
b.right -= B_V_SCROLL_BAR_WIDTH;
b.bottom = fDrawingModeMF->Frame().top - 10.0;
fObjectLV = new ObjectListView(b, "object list", B_SINGLE_SELECTION_LIST);
fObjectLV->SetSelectionMessage(new BMessage(MSG_OBJECT_SELECTED));
// wrap a scroll view around the list view
scrollView = new BScrollView("list scroller", fObjectLV,
B_FOLLOW_NONE, 0, false, true, B_FANCY_BORDER);
controlGroup->AddChild(scrollView);
// enforce some size limits
float minWidth = controlGroup->Frame().Width() + 30.0;
float minHeight = fPenSizeS->Frame().bottom
+ menuBar->Bounds().Height() + 15.0;
float maxWidth = minWidth * 4.0;
float maxHeight = minHeight + 100;
SetSizeLimits(minWidth, maxWidth, minHeight, maxHeight);
ResizeTo(max_c(frame.Width(), minWidth), max_c(frame.Height(), minHeight));
_UpdateControls();
}
ActivityWindow::ActivityWindow()
:
BWindow(BRect(100, 100, 500, 350), B_TRANSLATE_SYSTEM_NAME("ActivityMonitor"),
B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE)
{
BMessage settings;
_LoadSettings(settings);
BRect frame;
if (settings.FindRect("window frame", &frame) == B_OK) {
MoveTo(frame.LeftTop());
ResizeTo(frame.Width(), frame.Height());
}
#ifdef __HAIKU__
BGroupLayout* layout = new BGroupLayout(B_VERTICAL, 0);
SetLayout(layout);
// create GUI
BMenuBar* menuBar = new BMenuBar("menu");
layout->AddView(menuBar);
fLayout = new BGroupLayout(B_VERTICAL);
float inset = ceilf(be_plain_font->Size() * 0.7);
fLayout->SetInsets(inset, inset, inset, inset);
fLayout->SetSpacing(inset);
BView* top = new BView("top", 0, fLayout);
top->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
layout->AddView(top);
BMessage viewState;
int32 count = 0;
for (int32 i = 0; settings.FindMessage("activity view", i, &viewState)
== B_OK; i++) {
ActivityView* view = new ActivityView("ActivityMonitor", &viewState);
fLayout->AddItem(view->CreateHistoryLayoutItem());
fLayout->AddItem(view->CreateLegendLayoutItem());
count++;
}
if (count == 0) {
// Add default views (memory & CPU usage)
_AddDefaultView();
_AddDefaultView();
}
#else // !__HAIKU__
BView *layout = new BView(Bounds(), "topmost", B_FOLLOW_NONE, 0);
AddChild(layout);
// create GUI
BRect mbRect(Bounds());
mbRect.bottom = 10;
BMenuBar* menuBar = new BMenuBar(mbRect, "menu");
layout->AddChild(menuBar);
BRect topRect(Bounds());
topRect.top = menuBar->Bounds().bottom + 1;
BView* top = new BView(topRect, "top", B_FOLLOW_ALL, 0);
top->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
layout->AddChild(top);
BMessage viewState;
int32 count = 0;
ActivityView *aview;
BRect rect;
for (int32 i = 0; settings.FindMessage("activity view", i, &viewState)
== B_OK; i++) {
aview = new ActivityView("ActivityMonitor", &viewState);
if (!rect.IsValid())
rect = aview->Bounds();
else
rect.OffsetBySelf(0.0, aview->Bounds().Height());
top->AddChild(aview);
count++;
}
if (count == 0)
top->AddChild(new ActivityView("ActivityMonitor", NULL));
#endif
// add menu
// "File" menu
BMenu* menu = new BMenu(B_TRANSLATE("File"));
menu->AddItem(new BMenuItem(B_TRANSLATE("Add graph"),
new BMessage(kMsgAddView)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
menu->SetTargetForItems(this);
menuBar->AddItem(menu);
// "Settings" menu
menu = new BMenu(B_TRANSLATE("Settings"));
menu->AddItem(new BMenuItem(B_TRANSLATE("Settings" B_UTF8_ELLIPSIS),
new BMessage(kMsgShowSettings)));
menu->SetTargetForItems(this);
menuBar->AddItem(menu);
}
void
PadView::DisplayMenu(BPoint where, LaunchButton* button) const
{
MainWindow* window = dynamic_cast<MainWindow*>(Window());
if (window == NULL)
return;
LaunchButton* nearestButton = button;
if (!nearestButton) {
// find the nearest button
for (int32 i = 0; (nearestButton = ButtonAt(i)); i++) {
if (nearestButton->Frame().top > where.y)
break;
}
}
BPopUpMenu* menu = new BPopUpMenu(B_TRANSLATE("launch popup"), false, false);
// add button
BMessage* message = new BMessage(MSG_ADD_SLOT);
message->AddPointer("be:source", (void*)nearestButton);
BMenuItem* item = new BMenuItem(B_TRANSLATE("Add button here"), message);
item->SetTarget(window);
menu->AddItem(item);
// button options
if (button) {
// clear button
message = new BMessage(MSG_CLEAR_SLOT);
message->AddPointer("be:source", (void*)button);
item = new BMenuItem(B_TRANSLATE("Clear button"), message);
item->SetTarget(window);
menu->AddItem(item);
// remove button
message = new BMessage(MSG_REMOVE_SLOT);
message->AddPointer("be:source", (void*)button);
item = new BMenuItem(B_TRANSLATE("Remove button"), message);
item->SetTarget(window);
menu->AddItem(item);
// Open containing folder button
if (button->Ref() != NULL) {
message = new BMessage(MSG_OPEN_CONTAINING_FOLDER);
message->AddPointer("be:source", (void*)button);
item = new BMenuItem(B_TRANSLATE("Open containing folder"), message);
item->SetTarget(window);
menu->AddItem(item);
}
// set button description
if (button->Ref()) {
message = new BMessage(MSG_SET_DESCRIPTION);
message->AddPointer("be:source", (void*)button);
item = new BMenuItem(B_TRANSLATE("Set description"B_UTF8_ELLIPSIS),
message);
item->SetTarget(window);
menu->AddItem(item);
}
}
menu->AddSeparatorItem();
// window settings
BMenu* settingsM = new BMenu(B_TRANSLATE("Settings"));
settingsM->SetFont(be_plain_font);
const char* toggleLayoutLabel;
if (fButtonLayout->Orientation() == B_HORIZONTAL)
toggleLayoutLabel = B_TRANSLATE("Vertical layout");
else
toggleLayoutLabel = B_TRANSLATE("Horizontal layout");
item = new BMenuItem(toggleLayoutLabel, new BMessage(MSG_TOGGLE_LAYOUT));
item->SetTarget(this);
settingsM->AddItem(item);
BMenu* iconSizeM = new BMenu(B_TRANSLATE("Icon size"));
for (uint32 i = 0; i < sizeof(kIconSizes) / sizeof(uint32); i++) {
uint32 iconSize = kIconSizes[i];
message = new BMessage(MSG_SET_ICON_SIZE);
message->AddInt32("size", iconSize);
BString label;
label << iconSize << " x " << iconSize;
item = new BMenuItem(label.String(), message);
item->SetTarget(this);
item->SetMarked(IconSize() == iconSize);
iconSizeM->AddItem(item);
}
settingsM->AddItem(iconSizeM);
item = new BMenuItem(B_TRANSLATE("Ignore double-click"),
new BMessage(MSG_SET_IGNORE_DOUBLECLICK));
item->SetTarget(this);
item->SetMarked(IgnoreDoubleClick());
settingsM->AddItem(item);
uint32 what = window->Look() == B_BORDERED_WINDOW_LOOK ? MSG_SHOW_BORDER : MSG_HIDE_BORDER;
item = new BMenuItem(B_TRANSLATE("Show window border"), new BMessage(what));
item->SetTarget(window);
item->SetMarked(what == MSG_HIDE_BORDER);
settingsM->AddItem(item);
item = new BMenuItem(B_TRANSLATE("Auto-raise"), new BMessage(MSG_TOGGLE_AUTORAISE));
item->SetTarget(window);
item->SetMarked(window->AutoRaise());
settingsM->AddItem(item);
item = new BMenuItem(B_TRANSLATE("Show on all workspaces"), new BMessage(MSG_SHOW_ON_ALL_WORKSPACES));
item->SetTarget(window);
item->SetMarked(window->ShowOnAllWorkspaces());
settingsM->AddItem(item);
menu->AddItem(settingsM);
menu->AddSeparatorItem();
// pad commands
BMenu* padM = new BMenu(B_TRANSLATE("Pad"));
padM->SetFont(be_plain_font);
// new pad
item = new BMenuItem(B_TRANSLATE("New"), new BMessage(MSG_ADD_WINDOW));
item->SetTarget(be_app);
padM->AddItem(item);
// new pad
item = new BMenuItem(B_TRANSLATE("Clone"), new BMessage(MSG_ADD_WINDOW));
item->SetTarget(window);
padM->AddItem(item);
padM->AddSeparatorItem();
// close
item = new BMenuItem(B_TRANSLATE("Close"), new BMessage(B_QUIT_REQUESTED));
item->SetTarget(window);
padM->AddItem(item);
menu->AddItem(padM);
// app commands
BMenu* appM = new BMenu(B_TRANSLATE_SYSTEM_NAME("LaunchBox"));
appM->SetFont(be_plain_font);
// quit
item = new BMenuItem(B_TRANSLATE("Quit"), new BMessage(B_QUIT_REQUESTED));
item->SetTarget(be_app);
appM->AddItem(item);
menu->AddItem(appM);
// finish popup
menu->SetAsyncAutoDestruct(true);
menu->SetFont(be_plain_font);
where = ConvertToScreen(where);
BRect mouseRect(where, where);
mouseRect.InsetBy(-4.0, -4.0);
menu->Go(where, true, false, mouseRect, true);
}
TeapotWindow::TeapotWindow(BRect rect, const char* name, window_type wt,
ulong something)
:
BDirectWindow(rect, name, wt, something)
{
GLenum type = BGL_RGB | BGL_DEPTH | BGL_DOUBLE;
Lock();
BRect bounds = Bounds();
bounds.bottom = bounds.top + 14;
BMenuBar* menuBar = new BMenuBar(bounds, "main menu");
BMenu* menu;
BMessage msg(kMsgAddModel);
menuBar->AddItem(menu = new BMenu(B_TRANSLATE("File")));
AddChild(menuBar);
menuBar->ResizeToPreferred();
bounds = Bounds();
bounds.top = menuBar->Bounds().bottom + 1;
BView *subView = new BView(bounds, "subview", B_FOLLOW_ALL, 0);
AddChild(subView);
bounds = subView->Bounds();
fObjectView = new(std::nothrow) ObjectView(bounds, "objectView",
B_FOLLOW_ALL_SIDES, type);
subView->AddChild(fObjectView);
BMenuItem* item;
msg.AddInt32("num", 256);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Add a teapot"),
new BMessage(msg), 'N'));
item->SetTarget(fObjectView);
menu->AddSeparatorItem();
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
item->SetTarget(be_app);
msg.RemoveName("num");
menuBar->AddItem(menu = new BMenu(B_TRANSLATE("Options")));
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Perspective"),
new BMessage(kMsgPerspective)));
item->SetTarget(fObjectView);
item->SetMarked(false);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("FPS display"),
new BMessage(kMsgFPS)));
item->SetTarget(fObjectView);
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Filled polygons"),
new BMessage(kMsgFilled)));
item->SetTarget(fObjectView);
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Lighting"),
new BMessage(kMsgLighting)));
item->SetTarget(fObjectView);
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Backface culling"),
new BMessage(kMsgCulling)));
item->SetTarget(fObjectView);
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Z-buffered"),
new BMessage(kMsgZBuffer)));
item->SetTarget(fObjectView);
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Gouraud shading"),
new BMessage(kMsgGouraud)));
item->SetTarget(fObjectView);
item->SetMarked(true);
// menu->AddItem(item = new BMenuItem("Texture mapped", new BMessage(kMsgTextured)));
// item->SetTarget(fObjectView);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Fog"),
new BMessage(kMsgFog)));
item->SetTarget(fObjectView);
BMenu *subMenu;
menuBar->AddItem(menu = new BMenu(B_TRANSLATE("Lights")));
msg.what = kMsgLights;
msg.AddInt32("num", 1);
menu->AddItem(item = new BMenuItem(subMenu =
new BMenu(B_TRANSLATE("Upper center")), NULL));
item->SetTarget(fObjectView);
msg.AddInt32("color", lightNone);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Off"),
new BMessage(msg)));
item->SetTarget(fObjectView);
subMenu->AddSeparatorItem();
msg.ReplaceInt32("color", lightWhite);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("White"),
new BMessage(msg)));
item->SetTarget(fObjectView);
item->SetMarked(true);
msg.ReplaceInt32("color", lightYellow);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Yellow"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightBlue);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Blue"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightRed);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Red"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightGreen);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Green"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.RemoveName("color");
msg.ReplaceInt32("num", 2);
menu->AddItem(item = new BMenuItem(subMenu =
new BMenu(B_TRANSLATE("Lower left")), NULL));
item->SetTarget(fObjectView);
msg.AddInt32("color", lightNone);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Off"),
new BMessage(msg)));
item->SetTarget(fObjectView);
subMenu->AddSeparatorItem();
msg.ReplaceInt32("color", lightWhite);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("White"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightYellow);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Yellow"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightBlue);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Blue"),
new BMessage(msg)));
item->SetTarget(fObjectView);
item->SetMarked(true);
msg.ReplaceInt32("color", lightRed);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Red"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightGreen);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Green"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.RemoveName("color");
msg.ReplaceInt32("num", 3);
menu->AddItem(item = new BMenuItem(subMenu =
new BMenu(B_TRANSLATE("Right")), NULL));
item->SetTarget(fObjectView);
msg.AddInt32("color", lightNone);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Off"),
new BMessage(msg)));
item->SetTarget(fObjectView);
item->SetMarked(true);
subMenu->AddSeparatorItem();
msg.ReplaceInt32("color", lightWhite);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("White"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightYellow);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Yellow"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightBlue);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Blue"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightRed);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Red"),
new BMessage(msg)));
item->SetTarget(fObjectView);
msg.ReplaceInt32("color", lightGreen);
subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("Green"),
new BMessage(msg)));
item->SetTarget(fObjectView);
float f = menuBar->Bounds().IntegerHeight() + 1;
SetSizeLimits(32, 1024, 32 + f, 1024 + f);
//TODO: verify, adding an height to x seems strange
Unlock();
}
FileTypesWindow::FileTypesWindow(const BMessage& settings)
:
BWindow(_Frame(settings), B_TRANSLATE_SYSTEM_NAME("FileTypes"),
B_TITLED_WINDOW, B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS
| B_AUTO_UPDATE_SIZE_LIMITS),
fNewTypeWindow(NULL)
{
bool showIcons;
bool showRule;
if (settings.FindBool("show_icons", &showIcons) != B_OK)
showIcons = true;
if (settings.FindBool("show_rule", &showRule) != B_OK)
showRule = false;
float padding = be_control_look->DefaultItemSpacing();
BAlignment labelAlignment = be_control_look->DefaultLabelAlignment();
BAlignment fullAlignment(B_ALIGN_USE_FULL_WIDTH, B_ALIGN_USE_FULL_HEIGHT);
// add the menu
BMenuBar* menuBar = new BMenuBar("");
BMenu* menu = new BMenu(B_TRANSLATE("File"));
BMenuItem* item = new BMenuItem(
B_TRANSLATE("New resource file" B_UTF8_ELLIPSIS), NULL, 'N',
B_COMMAND_KEY);
item->SetEnabled(false);
menu->AddItem(item);
BMenu* recentsMenu = BRecentFilesList::NewFileListMenu(
B_TRANSLATE("Open" B_UTF8_ELLIPSIS), NULL, NULL,
be_app, 10, false, NULL, kSignature);
item = new BMenuItem(recentsMenu, new BMessage(kMsgOpenFilePanel));
item->SetShortcut('O', B_COMMAND_KEY);
menu->AddItem(item);
menu->AddItem(new BMenuItem(
B_TRANSLATE("Application types" B_UTF8_ELLIPSIS),
new BMessage(kMsgOpenApplicationTypesWindow)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q', B_COMMAND_KEY));
menu->SetTargetForItems(be_app);
menuBar->AddItem(menu);
menu = new BMenu(B_TRANSLATE("Settings"));
item = new BMenuItem(B_TRANSLATE("Show icons in list"),
new BMessage(kMsgToggleIcons));
item->SetMarked(showIcons);
item->SetTarget(this);
menu->AddItem(item);
item = new BMenuItem(B_TRANSLATE("Show recognition rule"),
new BMessage(kMsgToggleRule));
item->SetMarked(showRule);
item->SetTarget(this);
menu->AddItem(item);
menuBar->AddItem(menu);
menuBar->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP));
// MIME Types list
BButton* addTypeButton = new BButton("add",
B_TRANSLATE("Add" B_UTF8_ELLIPSIS), new BMessage(kMsgAddType));
fRemoveTypeButton = new BButton("remove", B_TRANSLATE("Remove"),
new BMessage(kMsgRemoveType) );
fTypeListView = new MimeTypeListView("typeview", NULL, showIcons, false);
fTypeListView->SetSelectionMessage(new BMessage(kMsgTypeSelected));
fTypeListView->SetExplicitMinSize(BSize(200, B_SIZE_UNSET));
BScrollView* typeListScrollView = new BScrollView("scrollview",
fTypeListView, B_FRAME_EVENTS | B_WILL_DRAW, false, true);
// "Icon" group
fIconView = new TypeIconView("icon");
fIconBox = new BBox("Icon BBox");
fIconBox->SetLabel(B_TRANSLATE("Icon"));
BLayoutBuilder::Group<>(fIconBox, B_VERTICAL, padding)
.SetInsets(padding)
.AddGlue(1)
.Add(fIconView, 3)
.AddGlue(1);
// "File Recognition" group
fRecognitionBox = new BBox("Recognition Box");
fRecognitionBox->SetLabel(B_TRANSLATE("File recognition"));
fRecognitionBox->SetExplicitAlignment(fullAlignment);
fExtensionLabel = new StringView(B_TRANSLATE("Extensions:"), NULL);
fExtensionLabel->LabelView()->SetExplicitAlignment(labelAlignment);
fAddExtensionButton = new BButton("add ext",
B_TRANSLATE("Add" B_UTF8_ELLIPSIS), new BMessage(kMsgAddExtension));
fAddExtensionButton->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fRemoveExtensionButton = new BButton("remove ext", B_TRANSLATE("Remove"),
new BMessage(kMsgRemoveExtension));
fExtensionListView = new ExtensionListView("listview ext",
B_SINGLE_SELECTION_LIST);
fExtensionListView->SetSelectionMessage(
new BMessage(kMsgExtensionSelected));
fExtensionListView->SetInvocationMessage(
new BMessage(kMsgExtensionInvoked));
BScrollView* scrollView = new BScrollView("scrollview ext",
fExtensionListView, B_FRAME_EVENTS | B_WILL_DRAW, false, true);
fRuleControl = new BTextControl("rule", B_TRANSLATE("Rule:"), "",
new BMessage(kMsgRuleEntered));
fRuleControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fRuleControl->Hide();
BLayoutBuilder::Grid<>(fRecognitionBox, padding, padding / 2)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fExtensionLabel->LabelView(), 0, 0)
.Add(scrollView, 0, 1, 2, 2)
.Add(fAddExtensionButton, 2, 1)
.Add(fRemoveExtensionButton, 2, 2)
.Add(fRuleControl, 0, 3, 3, 1);
// "Description" group
fDescriptionBox = new BBox("description BBox");
fDescriptionBox->SetLabel(B_TRANSLATE("Description"));
fDescriptionBox->SetExplicitAlignment(fullAlignment);
fInternalNameView = new StringView(B_TRANSLATE("Internal name:"), NULL);
fInternalNameView->SetEnabled(false);
fTypeNameControl = new BTextControl("type", B_TRANSLATE("Type name:"), "",
new BMessage(kMsgTypeEntered));
fDescriptionControl = new BTextControl("description",
B_TRANSLATE("Description:"), "", new BMessage(kMsgDescriptionEntered));
BLayoutBuilder::Grid<>(fDescriptionBox, padding / 2, padding / 2)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fInternalNameView->LabelView(), 0, 0)
.Add(fInternalNameView->TextView(), 1, 0)
.Add(fTypeNameControl->CreateLabelLayoutItem(), 0, 1)
.Add(fTypeNameControl->CreateTextViewLayoutItem(), 1, 1, 2)
.Add(fDescriptionControl->CreateLabelLayoutItem(), 0, 2)
.Add(fDescriptionControl->CreateTextViewLayoutItem(), 1, 2, 2);
// "Preferred Application" group
fPreferredBox = new BBox("preferred BBox");
fPreferredBox->SetLabel(B_TRANSLATE("Preferred application"));
menu = new BPopUpMenu("preferred");
menu->AddItem(item = new BMenuItem(B_TRANSLATE("None"),
new BMessage(kMsgPreferredAppChosen)));
item->SetMarked(true);
fPreferredField = new BMenuField("preferred", (char*)NULL, menu);
fSelectButton = new BButton("select",
B_TRANSLATE("Select" B_UTF8_ELLIPSIS),
new BMessage(kMsgSelectPreferredApp));
fSameAsButton = new BButton("same as",
B_TRANSLATE("Same as" B_UTF8_ELLIPSIS),
new BMessage(kMsgSamePreferredAppAs));
BLayoutBuilder::Group<>(fPreferredBox, B_HORIZONTAL, padding)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fPreferredField)
.Add(fSelectButton)
.Add(fSameAsButton);
// "Extra Attributes" group
fAttributeBox = new BBox("Attribute Box");
fAttributeBox->SetLabel(B_TRANSLATE("Extra attributes"));
fAddAttributeButton = new BButton("add attr",
B_TRANSLATE("Add" B_UTF8_ELLIPSIS), new BMessage(kMsgAddAttribute));
fAddAttributeButton->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fRemoveAttributeButton = new BButton("remove attr", B_TRANSLATE("Remove"),
new BMessage(kMsgRemoveAttribute));
fRemoveAttributeButton->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fMoveUpAttributeButton = new BButton("move up attr", B_TRANSLATE("Move up"),
new BMessage(kMsgMoveUpAttribute));
fMoveUpAttributeButton->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fMoveDownAttributeButton = new BButton("move down attr",
B_TRANSLATE("Move down"), new BMessage(kMsgMoveDownAttribute));
fMoveDownAttributeButton->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fAttributeListView = new AttributeListView("listview attr");
fAttributeListView->SetSelectionMessage(
new BMessage(kMsgAttributeSelected));
fAttributeListView->SetInvocationMessage(
new BMessage(kMsgAttributeInvoked));
BScrollView* attributesScroller = new BScrollView("scrollview attr",
fAttributeListView, B_FRAME_EVENTS | B_WILL_DRAW, false, true);
BLayoutBuilder::Group<>(fAttributeBox, B_HORIZONTAL, padding)
.SetInsets(padding, padding * 2, padding, padding)
.Add(attributesScroller, 1.0f)
.AddGroup(B_VERTICAL, padding / 2, 0.0f)
.SetInsets(0)
.Add(fAddAttributeButton)
.Add(fRemoveAttributeButton)
.AddStrut(padding)
.Add(fMoveUpAttributeButton)
.Add(fMoveDownAttributeButton)
.AddGlue();
fMainSplitView = new BSplitView(B_HORIZONTAL, floorf(padding / 2));
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.SetInsets(0)
.Add(menuBar)
.AddGroup(B_HORIZONTAL, 0)
.SetInsets(padding, padding, padding, padding)
.AddSplit(fMainSplitView)
.AddGroup(B_VERTICAL, padding)
.Add(typeListScrollView)
.AddGroup(B_HORIZONTAL, padding)
.Add(addTypeButton)
.Add(fRemoveTypeButton)
.AddGlue()
.End()
.End()
// Right side
.AddGroup(B_VERTICAL, padding)
.AddGroup(B_HORIZONTAL, padding)
.Add(fIconBox, 1)
.Add(fRecognitionBox, 3)
.End()
.Add(fDescriptionBox)
.Add(fPreferredBox)
.Add(fAttributeBox, 5);
_SetType(NULL);
_ShowSnifferRule(showRule);
float leftWeight;
float rightWeight;
if (settings.FindFloat("left_split_weight", &leftWeight) != B_OK
|| settings.FindFloat("right_split_weight", &rightWeight) != B_OK) {
leftWeight = 0.2;
rightWeight = 1.0 - leftWeight;
}
fMainSplitView->SetItemWeight(0, leftWeight, false);
fMainSplitView->SetItemWeight(1, rightWeight, true);
BMimeType::StartWatching(this);
}
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);
}
HEventRow* row = (HEventRow*)fEventList->CurrentSelection();
BButton* button = dynamic_cast<BButton*>(FindView("play"));
if (row != NULL) {
menufield->SetEnabled(true);
const char* path = row->Path();
if (path != NULL && strcmp(path, ""))
button->SetEnabled(true);
else
button->SetEnabled(false);
} else {
menufield->SetEnabled(false);
button->SetEnabled(false);
}
}
break;
}
case M_ITEM_MESSAGE:
{
entry_ref ref;
if (message->FindRef("refs", &ref) == B_OK) {
fEventList->SetPath(BPath(&ref).Path());
_UpdateZoomLimits();
}
break;
}
case M_NONE_MESSAGE:
{
fEventList->SetPath(NULL);
break;
}
default:
BWindow::MessageReceived(message);
}
}
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);
}
directory_which whichDirectories[] = {
B_SYSTEM_SOUNDS_DIRECTORY,
B_SYSTEM_NONPACKAGED_SOUNDS_DIRECTORY,
B_USER_SOUNDS_DIRECTORY,
B_USER_NONPACKAGED_SOUNDS_DIRECTORY,
};
for (size_t i = 0;
i < sizeof(whichDirectories) / sizeof(whichDirectories[0]); i++) {
BPath path;
BDirectory dir;
BEntry entry;
BPath item_path;
status_t err = find_directory(whichDirectories[i], &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);
}
}
}
SerialWindow::SerialWindow()
: BWindow(BRect(100, 100, 400, 400), SerialWindow::kWindowTitle,
B_DOCUMENT_WINDOW, B_QUIT_ON_WINDOW_CLOSE | B_AUTO_UPDATE_SIZE_LIMITS)
, fLogFilePanel(NULL)
{
BMenuBar* menuBar = new BMenuBar(Bounds(), "menuBar");
menuBar->ResizeToPreferred();
BRect r = Bounds();
r.top = menuBar->Bounds().bottom + 1;
r.right -= B_V_SCROLL_BAR_WIDTH;
fTermView = new TermView(r);
fTermView->ResizeToPreferred();
r = fTermView->Frame();
r.left = r.right + 1;
r.right = r.left + B_V_SCROLL_BAR_WIDTH;
r.top -= 1;
r.bottom -= B_H_SCROLL_BAR_HEIGHT - 1;
BScrollBar* scrollBar = new BScrollBar(r, "scrollbar", NULL, 0, 0,
B_VERTICAL);
scrollBar->SetTarget(fTermView);
ResizeTo(r.right - 1, r.bottom + B_H_SCROLL_BAR_HEIGHT - 1);
AddChild(menuBar);
AddChild(fTermView);
AddChild(scrollBar);
fConnectionMenu = new BMenu("Connection");
BMenu* fileMenu = new BMenu("File");
BMenu* settingsMenu = new BMenu("Settings");
fConnectionMenu->SetRadioMode(true);
menuBar->AddItem(fConnectionMenu);
menuBar->AddItem(fileMenu);
menuBar->AddItem(settingsMenu);
// TODO edit menu - what's in it ?
//BMenu* editMenu = new BMenu("Edit");
//menuBar->AddItem(editMenu);
BMenuItem* logFile = new BMenuItem("Log to file" B_UTF8_ELLIPSIS,
new BMessage(kMsgLogfile));
fileMenu->AddItem(logFile);
#if 0
// TODO implement these
BMenuItem* xmodemSend = new BMenuItem("X/Y/ZModem send" B_UTF8_ELLIPSIS,
NULL);
fileMenu->AddItem(xmodemSend);
BMenuItem* xmodemReceive = new BMenuItem(
"X/Y/Zmodem receive" B_UTF8_ELLIPSIS, NULL);
fileMenu->AddItem(xmodemReceive);
#endif
// Configuring all this by menus may be a bit unhandy. Make a setting
// window instead ?
fBaudrateMenu = new BMenu("Baud rate");
fBaudrateMenu->SetRadioMode(true);
settingsMenu->AddItem(fBaudrateMenu);
fParityMenu = new BMenu("Parity");
fParityMenu->SetRadioMode(true);
settingsMenu->AddItem(fParityMenu);
fStopbitsMenu = new BMenu("Stop bits");
fStopbitsMenu->SetRadioMode(true);
settingsMenu->AddItem(fStopbitsMenu);
fFlowcontrolMenu = new BMenu("Flow control");
fFlowcontrolMenu->SetRadioMode(true);
settingsMenu->AddItem(fFlowcontrolMenu);
fDatabitsMenu = new BMenu("Data bits");
fDatabitsMenu->SetRadioMode(true);
settingsMenu->AddItem(fDatabitsMenu);
BMessage* message = new BMessage(kMsgSettings);
message->AddInt32("parity", B_NO_PARITY);
BMenuItem* parityNone = new BMenuItem("None", message);
message = new BMessage(kMsgSettings);
message->AddInt32("parity", B_ODD_PARITY);
BMenuItem* parityOdd = new BMenuItem("Odd", message);
message = new BMessage(kMsgSettings);
message->AddInt32("parity", B_EVEN_PARITY);
BMenuItem* parityEven = new BMenuItem("Even", message);
fParityMenu->AddItem(parityNone);
fParityMenu->AddItem(parityOdd);
fParityMenu->AddItem(parityEven);
fParityMenu->SetTargetForItems(be_app);
message = new BMessage(kMsgSettings);
message->AddInt32("databits", B_DATA_BITS_7);
BMenuItem* data7 = new BMenuItem("7", message);
message = new BMessage(kMsgSettings);
message->AddInt32("databits", B_DATA_BITS_8);
BMenuItem* data8 = new BMenuItem("8", message);
fDatabitsMenu->AddItem(data7);
fDatabitsMenu->AddItem(data8);
fDatabitsMenu->SetTargetForItems(be_app);
message = new BMessage(kMsgSettings);
message->AddInt32("stopbits", B_STOP_BITS_1);
BMenuItem* stop1 = new BMenuItem("1", message);
message = new BMessage(kMsgSettings);
message->AddInt32("stopbits", B_STOP_BITS_2);
BMenuItem* stop2 = new BMenuItem("2", message);
fStopbitsMenu->AddItem(stop1);
fStopbitsMenu->AddItem(stop2);
fStopbitsMenu->SetTargetForItems(be_app);
// Loop backwards to add fastest rates at top of menu
for (int i = sizeof(kBaudrates) / sizeof(char*); --i >= 0;)
{
message = new BMessage(kMsgSettings);
message->AddInt32("baudrate", kBaudrateConstants[i]);
char buffer[7];
sprintf(buffer, "%d", kBaudrates[i]);
BMenuItem* item = new BMenuItem(buffer, message);
fBaudrateMenu->AddItem(item);
}
fBaudrateMenu->SetTargetForItems(be_app);
message = new BMessage(kMsgSettings);
message->AddInt32("flowcontrol", B_HARDWARE_CONTROL);
BMenuItem* hardware = new BMenuItem("Hardware", message);
message = new BMessage(kMsgSettings);
message->AddInt32("flowcontrol", B_SOFTWARE_CONTROL);
BMenuItem* software = new BMenuItem("Software", message);
message = new BMessage(kMsgSettings);
message->AddInt32("flowcontrol", B_HARDWARE_CONTROL | B_SOFTWARE_CONTROL);
BMenuItem* both = new BMenuItem("Both", message);
message = new BMessage(kMsgSettings);
message->AddInt32("flowcontrol", 0);
BMenuItem* noFlow = new BMenuItem("None", message);
fFlowcontrolMenu->AddItem(hardware);
fFlowcontrolMenu->AddItem(software);
fFlowcontrolMenu->AddItem(both);
fFlowcontrolMenu->AddItem(noFlow);
fFlowcontrolMenu->SetTargetForItems(be_app);
CenterOnScreen();
}
BMenuBar*
MainWindow::_CreateMenuBar()
{
BMenuBar* menuBar = new BMenuBar("main menu");
#undef B_TRANSLATE_CONTEXT
#define B_TRANSLATE_CONTEXT "Icon-O-Matic-Menus"
BMenu* fileMenu = new BMenu(B_TRANSLATE("File"));
BMenu* editMenu = new BMenu(B_TRANSLATE("Edit"));
BMenu* settingsMenu = new BMenu(B_TRANSLATE("Options"));
fPathMenu = new BMenu(B_TRANSLATE("Path"));
fStyleMenu = new BMenu(B_TRANSLATE("Style"));
fShapeMenu = new BMenu(B_TRANSLATE("Shape"));
fTransformerMenu = new BMenu(B_TRANSLATE("Transformer"));
fPropertyMenu = new BMenu(B_TRANSLATE("Properties"));
fSwatchMenu = new BMenu(B_TRANSLATE("Swatches"));
menuBar->AddItem(fileMenu);
menuBar->AddItem(editMenu);
menuBar->AddItem(settingsMenu);
// File
#undef B_TRANSLATE_CONTEXT
#define B_TRANSLATE_CONTEXT "Icon-O-Matic-Menu-File"
BMenuItem* item = new BMenuItem(B_TRANSLATE("New"),
new BMessage(MSG_NEW), 'N');
fileMenu->AddItem(item);
item->SetTarget(be_app);
item = new BMenuItem(B_TRANSLATE("Open"B_UTF8_ELLIPSIS),
new BMessage(MSG_OPEN), 'O');
fileMenu->AddItem(item);
BMessage* appendMessage = new BMessage(MSG_APPEND);
appendMessage->AddPointer("window", this);
item = new BMenuItem(B_TRANSLATE("Append"B_UTF8_ELLIPSIS),
appendMessage, 'O', B_SHIFT_KEY);
fileMenu->AddItem(item);
item->SetTarget(be_app);
fileMenu->AddSeparatorItem();
fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Save"),
new BMessage(MSG_SAVE), 'S'));
fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Save as"B_UTF8_ELLIPSIS),
new BMessage(MSG_SAVE_AS), 'S', B_SHIFT_KEY));
fileMenu->AddSeparatorItem();
fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Export"),
new BMessage(MSG_EXPORT), 'P'));
fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Export as"B_UTF8_ELLIPSIS),
new BMessage(MSG_EXPORT_AS), 'P', B_SHIFT_KEY));
fileMenu->AddSeparatorItem();
fileMenu->AddItem(new BMenuItem(B_TRANSLATE("Close"),
new BMessage(B_QUIT_REQUESTED), 'W'));
item = new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q');
fileMenu->AddItem(item);
item->SetTarget(be_app);
// Edit
#undef B_TRANSLATE_CONTEXT
#define B_TRANSLATE_CONTEXT "Icon-O-Matic-Menu-Edit"
fUndoMI = new BMenuItem(B_TRANSLATE("<nothing to undo>"),
new BMessage(MSG_UNDO), 'Z');
fRedoMI = new BMenuItem(B_TRANSLATE("<nothing to redo>"),
new BMessage(MSG_REDO), 'Z', B_SHIFT_KEY);
fUndoMI->SetEnabled(false);
fRedoMI->SetEnabled(false);
editMenu->AddItem(fUndoMI);
editMenu->AddItem(fRedoMI);
// Settings
#undef B_TRANSLATE_CONTEXT
#define B_TRANSLATE_CONTEXT "Icon-O-Matic-Menu-Settings"
BMenu* filterModeMenu = new BMenu(B_TRANSLATE("Snap to grid"));
BMessage* message = new BMessage(MSG_MOUSE_FILTER_MODE);
message->AddInt32("mode", SNAPPING_OFF);
fMouseFilterOffMI = new BMenuItem(B_TRANSLATE("Off"), message, '4');
filterModeMenu->AddItem(fMouseFilterOffMI);
message = new BMessage(MSG_MOUSE_FILTER_MODE);
message->AddInt32("mode", SNAPPING_64);
fMouseFilter64MI = new BMenuItem("64 x 64", message, '3');
filterModeMenu->AddItem(fMouseFilter64MI);
message = new BMessage(MSG_MOUSE_FILTER_MODE);
message->AddInt32("mode", SNAPPING_32);
fMouseFilter32MI = new BMenuItem("32 x 32", message, '2');
filterModeMenu->AddItem(fMouseFilter32MI);
message = new BMessage(MSG_MOUSE_FILTER_MODE);
message->AddInt32("mode", SNAPPING_16);
fMouseFilter16MI = new BMenuItem("16 x 16", message, '1');
filterModeMenu->AddItem(fMouseFilter16MI);
filterModeMenu->SetRadioMode(true);
settingsMenu->AddItem(filterModeMenu);
return menuBar;
}
void
ShowImageWindow::_AddMenus(BMenuBar* bar)
{
BMenu* menu = new BMenu(B_TRANSLATE("File"));
// Add recent files to "Open File" entry as sub-menu.
BMenuItem* item = new BMenuItem(BRecentFilesList::NewFileListMenu(
B_TRANSLATE("Open" B_UTF8_ELLIPSIS), NULL, NULL, be_app, 10, true,
NULL, kApplicationSignature), new BMessage(MSG_FILE_OPEN));
item->SetShortcut('O', 0);
item->SetTarget(be_app);
menu->AddItem(item);
menu->AddSeparatorItem();
BMenu* menuSaveAs = new BMenu(B_TRANSLATE("Save as" B_UTF8_ELLIPSIS),
B_ITEMS_IN_COLUMN);
BTranslationUtils::AddTranslationItems(menuSaveAs, B_TRANSLATOR_BITMAP);
// Fill Save As submenu with all types that can be converted
// to from the Be bitmap image format
menu->AddItem(menuSaveAs);
_AddItemMenu(menu, B_TRANSLATE("Close"), B_QUIT_REQUESTED, 'W', 0, this);
_AddItemMenu(menu, B_TRANSLATE("Move to Trash"), kMsgDeleteCurrentFile, 'T', 0, this);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Page setup" B_UTF8_ELLIPSIS),
MSG_PAGE_SETUP, 0, 0, this);
_AddItemMenu(menu, B_TRANSLATE("Print" B_UTF8_ELLIPSIS),
MSG_PREPARE_PRINT, 'P', 0, this);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Quit"), B_QUIT_REQUESTED, 'Q', 0, be_app);
bar->AddItem(menu);
menu = new BMenu(B_TRANSLATE("Edit"));
_AddItemMenu(menu, B_TRANSLATE("Copy"), B_COPY, 'C', 0, this, false);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Selection mode"), MSG_SELECTION_MODE, 0, 0,
this);
_AddItemMenu(menu, B_TRANSLATE("Clear selection"),
MSG_CLEAR_SELECT, 0, 0, this, false);
_AddItemMenu(menu, B_TRANSLATE("Select all"),
MSG_SELECT_ALL, 'A', 0, this);
bar->AddItem(menu);
menu = fBrowseMenu = new BMenu(B_TRANSLATE("Browse"));
_AddItemMenu(menu, B_TRANSLATE("First page"),
MSG_PAGE_FIRST, B_LEFT_ARROW, B_SHIFT_KEY, this);
_AddItemMenu(menu, B_TRANSLATE("Last page"),
MSG_PAGE_LAST, B_RIGHT_ARROW, B_SHIFT_KEY, this);
_AddItemMenu(menu, B_TRANSLATE("Previous page"),
MSG_PAGE_PREV, B_LEFT_ARROW, 0, this);
_AddItemMenu(menu, B_TRANSLATE("Next page"),
MSG_PAGE_NEXT, B_RIGHT_ARROW, 0, this);
fGoToPageMenu = new BMenu(B_TRANSLATE("Go to page"));
fGoToPageMenu->SetRadioMode(true);
menu->AddItem(fGoToPageMenu);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Previous file"),
MSG_FILE_PREV, B_UP_ARROW, 0, this);
_AddItemMenu(menu, B_TRANSLATE("Next file"),
MSG_FILE_NEXT, B_DOWN_ARROW, 0, this);
bar->AddItem(menu);
menu = new BMenu(B_TRANSLATE("Image"));
_AddItemMenu(menu, B_TRANSLATE("Rotate clockwise"),
MSG_ROTATE_90, 'R', 0, this);
_AddItemMenu(menu, B_TRANSLATE("Rotate counterclockwise"),
MSG_ROTATE_270, 'R', B_SHIFT_KEY, this);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Flip left to right"),
MSG_FLIP_LEFT_TO_RIGHT, 0, 0, this);
_AddItemMenu(menu, B_TRANSLATE("Flip top to bottom"),
MSG_FLIP_TOP_TO_BOTTOM, 0, 0, this);
menu->AddSeparatorItem();
_AddItemMenu(menu, B_TRANSLATE("Use as background" B_UTF8_ELLIPSIS),
MSG_DESKTOP_BACKGROUND, 0, 0, this);
bar->AddItem(menu);
}
SelectionWindow::SelectionWindow(BContainerWindow* window)
:
BWindow(BRect(0, 0, 270, 0), B_TRANSLATE("Select"), B_TITLED_WINDOW,
B_NOT_ZOOMABLE | B_NOT_MINIMIZABLE | B_NOT_V_RESIZABLE
| B_NO_WORKSPACE_ACTIVATION | B_ASYNCHRONOUS_CONTROLS
| B_NOT_ANCHORED_ON_ACTIVATE),
fParentWindow(window)
{
if (window->Feel() & kDesktopWindowFeel) {
// The window will not show up if we have
// B_FLOATING_SUBSET_WINDOW_FEEL and use it with the desktop window
// since it's never in front.
SetFeel(B_NORMAL_WINDOW_FEEL);
}
AddToSubset(fParentWindow);
BView* backgroundView = new BView(Bounds(), "bgView", B_FOLLOW_ALL,
B_WILL_DRAW);
backgroundView->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
AddChild(backgroundView);
BMenu* menu = new BPopUpMenu("");
menu->AddItem(new BMenuItem(B_TRANSLATE("starts with"), NULL));
menu->AddItem(new BMenuItem(B_TRANSLATE("ends with"), NULL));
menu->AddItem(new BMenuItem(B_TRANSLATE("contains"), NULL));
menu->AddItem(new BMenuItem(B_TRANSLATE("matches wildcard expression"),
NULL));
menu->AddItem(new BMenuItem(B_TRANSLATE("matches regular expression"),
NULL));
menu->SetLabelFromMarked(true);
menu->ItemAt(3)->SetMarked(true);
// Set wildcard matching to default.
// Set up the menu field
fMatchingTypeMenuField = new BMenuField(BRect(7, 6,
Bounds().right - 5, 0), NULL, B_TRANSLATE("Name"), menu);
backgroundView->AddChild(fMatchingTypeMenuField);
fMatchingTypeMenuField->SetDivider(fMatchingTypeMenuField->StringWidth(
B_TRANSLATE("Name")) + 8);
fMatchingTypeMenuField->ResizeToPreferred();
// Set up the expression text control
fExpressionTextControl = new BTextControl(BRect(7,
fMatchingTypeMenuField->Bounds().bottom + 11,
Bounds().right - 6, 0),
NULL, NULL, NULL, NULL, B_FOLLOW_LEFT_RIGHT);
backgroundView->AddChild(fExpressionTextControl);
fExpressionTextControl->ResizeToPreferred();
fExpressionTextControl->MakeFocus(true);
// Set up the Invert checkbox
fInverseCheckBox = new BCheckBox(
BRect(7, fExpressionTextControl->Frame().bottom + 6, 6, 6), NULL,
B_TRANSLATE("Invert"), NULL);
backgroundView->AddChild(fInverseCheckBox);
fInverseCheckBox->ResizeToPreferred();
// Set up the Ignore Case checkbox
fIgnoreCaseCheckBox = new BCheckBox(
BRect(fInverseCheckBox->Frame().right + 10,
fInverseCheckBox->Frame().top, 6, 6),
NULL, B_TRANSLATE("Ignore case"), NULL);
fIgnoreCaseCheckBox->SetValue(1);
backgroundView->AddChild(fIgnoreCaseCheckBox);
fIgnoreCaseCheckBox->ResizeToPreferred();
// Set up the Select button
fSelectButton = new BButton(BRect(0, 0, 5, 5), NULL,
B_TRANSLATE("Select"), new BMessage(kSelectButtonPressed),
B_FOLLOW_RIGHT);
backgroundView->AddChild(fSelectButton);
fSelectButton->ResizeToPreferred();
fSelectButton->MoveTo(Bounds().right - 10 - fSelectButton->Bounds().right,
fExpressionTextControl->Frame().bottom + 9);
fSelectButton->MakeDefault(true);
#if !B_BEOS_VERSION_DANO
fSelectButton->SetLowColor(backgroundView->ViewColor());
fSelectButton->SetViewColor(B_TRANSPARENT_COLOR);
#endif
font_height fh;
be_plain_font->GetHeight(&fh);
// Center the checkboxes vertically to the button
float topMiddleButton =
(fSelectButton->Bounds().Height() / 2 -
(fh.ascent + fh.descent + fh.leading + 4) / 2)
+ fSelectButton->Frame().top;
fInverseCheckBox->MoveTo(fInverseCheckBox->Frame().left, topMiddleButton);
fIgnoreCaseCheckBox->MoveTo(fIgnoreCaseCheckBox->Frame().left,
topMiddleButton);
float bottomMinWidth = 32 + fSelectButton->Bounds().Width()
+ fInverseCheckBox->Bounds().Width()
+ fIgnoreCaseCheckBox->Bounds().Width();
float topMinWidth = be_plain_font->StringWidth(
B_TRANSLATE("Name matches wildcard expression:###"));
float minWidth = bottomMinWidth > topMinWidth
? bottomMinWidth : topMinWidth;
class EscapeFilter : public BMessageFilter {
public:
EscapeFilter(BWindow* target)
:
BMessageFilter(B_KEY_DOWN),
fTarget(target)
{
}
virtual filter_result Filter(BMessage* message, BHandler** _target)
{
int8 byte;
if (message->what == B_KEY_DOWN
&& message->FindInt8("byte", &byte) == B_OK
&& byte == B_ESCAPE) {
fTarget->Hide();
return B_SKIP_MESSAGE;
}
return B_DISPATCH_MESSAGE;
}
private:
BWindow* fTarget;
};
AddCommonFilter(new(std::nothrow) EscapeFilter(this));
Run();
Lock();
ResizeTo(minWidth, fSelectButton->Frame().bottom + 6);
SetSizeLimits(minWidth, 1280, Bounds().bottom, Bounds().bottom);
MoveCloseToMouse();
Unlock();
}
CharismaWindow::CharismaWindow(BPoint origin):
BWindow(BRect(origin.x,origin.y,origin.x+200,origin.y+80),
"Charisma", B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_NOT_RESIZABLE|B_NOT_ZOOMABLE|B_WILL_ACCEPT_FIRST_CLICK)
{
BRect nullrect(0,0,0,0),r;
BMenu *m;
BWindow *w;
char buf[100];
isminim=0;
// le menu
menubar=new BMenuBar(BRect(0,0,0,0),"menu bar");
m=new BMenu("File");
m->AddItem(new BMenuItem("About…",new BMessage(kMsg_About)));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("Quit",new BMessage(B_QUIT_REQUESTED),'Q'));
menubar->AddItem(m);
m=new BMenu("Settings");
m->AddItem(new BMenuItem("Select Web Directory…",new BMessage(kMsg_SelectDirectory)));
m->AddSeparatorItem();
m->AddItem(extcontrol_item=new BMenuItem("External Control",new BMessage(kMsg_ExternalControl)));
m->AddItem(netposautoset_item=new BMenuItem("Net+ Autosettings",new BMessage(kMsg_NetposAutosettings)));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("Clear Hits",new BMessage(kMsg_ClearHits)));
menubar->AddItem(m);
AddChild(menubar);
// le fond gris
r=Frame();
setupview=new BView(
BRect(0,menubar->Frame().bottom,r.Width(),r.Height()),
"background",B_FOLLOW_NONE,B_WILL_DRAW);
setupview->SetViewColor(0xDD,0xDD,0xDD);
AddChild(setupview);
// "Mode"
m=new BPopUpMenu("");
m->AddItem(new BMenuItem("Disabled",MSG));
m->AddItem(new BMenuItem("Offline",MSG));
m->AddItem(new BMenuItem("Online",MSG));
modemenu=new BMenuField(
BRect(10.0f,10.0f,20.0f,20.0f),"mode",
"Mode:",
m);
BMenuField_resize(modemenu);
setupview->AddChild(modemenu);
// "Refresh"
m=new BPopUpMenu("");
m->AddItem(new BMenuItem("Dumb",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("Always",MSG));
m->AddItem(new BMenuItem("Once per session",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("After 1 hour",MSG));
m->AddItem(new BMenuItem("After 6 hours",MSG));
m->AddItem(new BMenuItem("After 12 hours",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("After 1 day",MSG));
m->AddItem(new BMenuItem("After 2 days",MSG));
m->AddItem(new BMenuItem("After 3 days",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("After 1 week",MSG));
m->AddItem(new BMenuItem("After 2 weeks",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("After 1 month",MSG));
m->AddItem(new BMenuItem("After 2 month",MSG));
m->AddItem(new BMenuItem("After 6 month",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("After 1 year",MSG));
m->AddItem(new BMenuItem("After 2 years",MSG));
m->AddSeparatorItem();
m->AddItem(new BMenuItem("never",MSG));
smartrefresh=new BMenuField(
rectunder(modemenu),"refresh",
"Refresh:",
m);
BMenuField_resize(smartrefresh);
setupview->AddChild(smartrefresh);
// "Hits"
r.left=10.0f;
r.top=smartrefresh->Frame().bottom+10.0f;
r.right=r.left+setupview->StringWidth("hits: 99999");
r.bottom=r.top+BView_textheight(setupview);
hits=new BStringView(r,"hits","");
setupview->AddChild(hits);
if(!gregistered){
sprintf(buf,"This copy is not registered");
r.left=10.0f;
r.top=hits->Frame().bottom+10.0f;
r.right=r.left+setupview->StringWidth(buf);
r.bottom=r.top+BView_textheight(setupview);
setupview->AddChild(new BStringView(r,NULL,buf));
}
r=BView_childrenframe(setupview);
setupview->ResizeTo(r.right+10,r.bottom+10);
r=setupview->Frame();
ResizeTo(r.right,r.bottom);
hitcount=0;
hitspulser=spawn_thread(pulsehits_,"StaminaWindow::pulsehits",
B_NORMAL_PRIORITY,this);
if(hitspulser<B_NO_ERROR)
fatal(__FILE__,__LINE__,"spawn_thread failed");
resume_thread(hitspulser);
selectdirpanel=new BFilePanel(
B_OPEN_PANEL,
&BMessenger(this),
NULL,
B_DIRECTORY_NODE,
false,
new BMessage(kMsg_DirSelected));
w=selectdirpanel->Window();
w->Lock();
w->SetTitle("Select Web Directory");
selectdirpanel->SetButtonLabel(B_DEFAULT_BUTTON,"Select");
r=w->FindView("cancel button")->Frame();
r.right=r.left-15.0f;
r.left=10.0f;
r.bottom=r.top+BView_textheight(w->ChildAt(0));
currentdir=new BStringView(r,"current","",B_FOLLOW_LEFT_RIGHT|B_FOLLOW_BOTTOM);
w->ChildAt(0)->AddChild(currentdir);
w->Unlock();
}
ApplicationTypeWindow::ApplicationTypeWindow(BPoint position,
const BEntry& entry)
:
BWindow(BRect(0.0f, 0.0f, 250.0f, 340.0f).OffsetBySelf(position),
B_TRANSLATE("Application type"), B_TITLED_WINDOW,
B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS |
B_FRAME_EVENTS | B_AUTO_UPDATE_SIZE_LIMITS),
fChangedProperties(0)
{
float padding = be_control_look->DefaultItemSpacing();
BAlignment labelAlignment = be_control_look->DefaultLabelAlignment();
BMenuBar* menuBar = new BMenuBar((char*)NULL);
menuBar->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_TOP));
BMenu* menu = new BMenu(B_TRANSLATE("File"));
fSaveMenuItem = new BMenuItem(B_TRANSLATE("Save"),
new BMessage(kMsgSave), 'S');
fSaveMenuItem->SetEnabled(false);
menu->AddItem(fSaveMenuItem);
BMenuItem* item;
menu->AddItem(item = new BMenuItem(
B_TRANSLATE("Save into resource file" B_UTF8_ELLIPSIS), NULL));
item->SetEnabled(false);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Close"),
new BMessage(B_QUIT_REQUESTED), 'W', B_COMMAND_KEY));
menuBar->AddItem(menu);
// Signature
fSignatureControl = new BTextControl(B_TRANSLATE("Signature:"), NULL,
new BMessage(kMsgSignatureChanged));
fSignatureControl->SetModificationMessage(
new BMessage(kMsgSignatureChanged));
// filter out invalid characters that can't be part of a MIME type name
BTextView* textView = fSignatureControl->TextView();
textView->SetMaxBytes(B_MIME_TYPE_LENGTH);
const char* disallowedCharacters = "<>@,;:\"()[]?= ";
for (int32 i = 0; disallowedCharacters[i]; i++) {
textView->DisallowChar(disallowedCharacters[i]);
}
// "Application Flags" group
BBox* flagsBox = new BBox("flagsBox");
fFlagsCheckBox = new BCheckBox("flags", B_TRANSLATE("Application flags"),
new BMessage(kMsgToggleAppFlags));
fFlagsCheckBox->SetValue(B_CONTROL_ON);
fSingleLaunchButton = new BRadioButton("single",
B_TRANSLATE("Single launch"), new BMessage(kMsgAppFlagsChanged));
fMultipleLaunchButton = new BRadioButton("multiple",
B_TRANSLATE("Multiple launch"), new BMessage(kMsgAppFlagsChanged));
fExclusiveLaunchButton = new BRadioButton("exclusive",
B_TRANSLATE("Exclusive launch"), new BMessage(kMsgAppFlagsChanged));
fArgsOnlyCheckBox = new BCheckBox("args only", B_TRANSLATE("Args only"),
new BMessage(kMsgAppFlagsChanged));
fBackgroundAppCheckBox = new BCheckBox("background",
B_TRANSLATE("Background app"), new BMessage(kMsgAppFlagsChanged));
BLayoutBuilder::Grid<>(flagsBox, 0, 0)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fSingleLaunchButton, 0, 0).Add(fArgsOnlyCheckBox, 1, 0)
.Add(fMultipleLaunchButton, 0, 1).Add(fBackgroundAppCheckBox, 1, 1)
.Add(fExclusiveLaunchButton, 0, 2);
flagsBox->SetLabel(fFlagsCheckBox);
// "Icon" group
BBox* iconBox = new BBox("IconBox");
iconBox->SetLabel(B_TRANSLATE("Icon"));
fIconView = new IconView("icon");
fIconView->SetModificationMessage(new BMessage(kMsgIconChanged));
BLayoutBuilder::Group<>(iconBox, B_HORIZONTAL)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fIconView);
// "Supported Types" group
BBox* typeBox = new BBox("typesBox");
typeBox->SetLabel(B_TRANSLATE("Supported types"));
fTypeListView = new SupportedTypeListView("Suppported Types",
B_SINGLE_SELECTION_LIST);
fTypeListView->SetSelectionMessage(new BMessage(kMsgTypeSelected));
BScrollView* scrollView = new BScrollView("type scrollview", fTypeListView,
B_FRAME_EVENTS | B_WILL_DRAW, false, true);
fAddTypeButton = new BButton("add type",
B_TRANSLATE("Add" B_UTF8_ELLIPSIS), new BMessage(kMsgAddType));
fRemoveTypeButton = new BButton("remove type", B_TRANSLATE("Remove"),
new BMessage(kMsgRemoveType));
fTypeIconView = new IconView("type icon");
BGroupView* iconHolder = new BGroupView(B_HORIZONTAL);
iconHolder->AddChild(fTypeIconView);
fTypeIconView->SetModificationMessage(new BMessage(kMsgTypeIconsChanged));
BLayoutBuilder::Grid<>(typeBox, padding, padding)
.SetInsets(padding, padding * 2, padding, padding)
.Add(scrollView, 0, 0, 1, 4)
.Add(fAddTypeButton, 1, 0, 1, 2)
.Add(fRemoveTypeButton, 1, 2, 1, 2)
.Add(iconHolder, 2, 1, 1, 2)
.SetColumnWeight(0, 3)
.SetColumnWeight(1, 2)
.SetColumnWeight(2, 1);
iconHolder->SetExplicitAlignment(
BAlignment(B_ALIGN_CENTER, B_ALIGN_MIDDLE));
// "Version Info" group
BBox* versionBox = new BBox("versionBox");
versionBox->SetLabel(B_TRANSLATE("Version info"));
fMajorVersionControl = new BTextControl(B_TRANSLATE("Version:"),
NULL, NULL);
_MakeNumberTextControl(fMajorVersionControl);
fMiddleVersionControl = new BTextControl(".", NULL, NULL);
_MakeNumberTextControl(fMiddleVersionControl);
fMinorVersionControl = new BTextControl(".", NULL, NULL);
_MakeNumberTextControl(fMinorVersionControl);
fVarietyMenu = new BPopUpMenu("variety", true, true);
fVarietyMenu->AddItem(new BMenuItem(B_TRANSLATE("Development"), NULL));
fVarietyMenu->AddItem(new BMenuItem(B_TRANSLATE("Alpha"), NULL));
fVarietyMenu->AddItem(new BMenuItem(B_TRANSLATE("Beta"), NULL));
fVarietyMenu->AddItem(new BMenuItem(B_TRANSLATE("Gamma"), NULL));
item = new BMenuItem(B_TRANSLATE("Golden master"), NULL);
fVarietyMenu->AddItem(item);
item->SetMarked(true);
fVarietyMenu->AddItem(new BMenuItem(B_TRANSLATE("Final"), NULL));
BMenuField* varietyField = new BMenuField("", fVarietyMenu);
fInternalVersionControl = new BTextControl("/", NULL, NULL);
fShortDescriptionControl =
new BTextControl(B_TRANSLATE("Short description:"), NULL, NULL);
// TODO: workaround for a GCC 4.1.0 bug? Or is that really what the standard says?
version_info versionInfo;
fShortDescriptionControl->TextView()->SetMaxBytes(
sizeof(versionInfo.short_info));
BStringView* longLabel = new BStringView(NULL,
B_TRANSLATE("Long description:"));
longLabel->SetExplicitAlignment(labelAlignment);
fLongDescriptionView = new TabFilteringTextView("long desc");
fLongDescriptionView->SetMaxBytes(sizeof(versionInfo.long_info));
scrollView = new BScrollView("desc scrollview", fLongDescriptionView,
B_FRAME_EVENTS | B_WILL_DRAW, false, true);
// TODO: remove workaround (bug #5678)
BSize minScrollSize = scrollView->ScrollBar(B_VERTICAL)->MinSize();
minScrollSize.width += fLongDescriptionView->MinSize().width;
scrollView->SetExplicitMinSize(minScrollSize);
// Manually set a minimum size for the version text controls
// TODO: the same does not work when applied to the layout items
float width = be_plain_font->StringWidth("99") + 16;
fMajorVersionControl->TextView()->SetExplicitMinSize(
BSize(width, fMajorVersionControl->MinSize().height));
fMiddleVersionControl->TextView()->SetExplicitMinSize(
BSize(width, fMiddleVersionControl->MinSize().height));
fMinorVersionControl->TextView()->SetExplicitMinSize(
BSize(width, fMinorVersionControl->MinSize().height));
fInternalVersionControl->TextView()->SetExplicitMinSize(
BSize(width, fInternalVersionControl->MinSize().height));
BLayoutBuilder::Grid<>(versionBox, padding / 2, padding / 2)
.SetInsets(padding, padding * 2, padding, padding)
.Add(fMajorVersionControl->CreateLabelLayoutItem(), 0, 0)
.Add(fMajorVersionControl->CreateTextViewLayoutItem(), 1, 0)
.Add(fMiddleVersionControl, 2, 0, 2)
.Add(fMinorVersionControl, 4, 0, 2)
.Add(varietyField, 6, 0, 3)
.Add(fInternalVersionControl, 9, 0, 2)
.Add(fShortDescriptionControl->CreateLabelLayoutItem(), 0, 1)
.Add(fShortDescriptionControl->CreateTextViewLayoutItem(), 1, 1, 10)
.Add(longLabel, 0, 2)
.Add(scrollView, 1, 2, 10, 3)
.SetRowWeight(3, 3);
// put it all together
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.SetInsets(0, 0, 0, 0)
.Add(menuBar)
.AddGroup(B_VERTICAL, padding)
.SetInsets(padding, padding, padding, padding)
.Add(fSignatureControl)
.AddGroup(B_HORIZONTAL, padding)
.Add(flagsBox, 3)
.Add(iconBox, 1)
.End()
.Add(typeBox)
.Add(versionBox);
SetKeyMenuBar(menuBar);
fSignatureControl->MakeFocus(true);
BMimeType::StartWatching(this);
_SetTo(entry);
}
BMenuBar*
BoardWindow::_CreateMenuBar(void)
{
BMenuBar* menuBar = new BMenuBar("BoardWindowMenuBar");
BMenuItem* menuItem;
BMenu* applicationMenu = new BMenu("Application");
menuBar->AddItem(applicationMenu);
BMenu* newSubMenu = new BMenu("New");
applicationMenu->AddItem(newSubMenu);
menuItem = new BMenuItem("Blitz Game" B_UTF8_ELLIPSIS, NULL, 'B');
newSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Long Game" B_UTF8_ELLIPSIS, NULL, 'L');
newSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
newSubMenu->AddSeparatorItem();
menuItem = new BMenuItem("Position Setup" B_UTF8_ELLIPSIS, NULL, 'P');
newSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Engine Match" B_UTF8_ELLIPSIS, NULL, 'E');
newSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
BMenu* openSubMenu = new BMenu("Open");
applicationMenu->AddItem(openSubMenu);
menuItem = new BMenuItem("PGN File" B_UTF8_ELLIPSIS, NULL, 'O');
openSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Database" B_UTF8_ELLIPSIS, NULL, 'D');
openSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
applicationMenu->AddSeparatorItem();
menuItem = new BMenuItem("Save" B_UTF8_ELLIPSIS, NULL, 'S');
applicationMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
applicationMenu->AddSeparatorItem();
menuItem = new BMenuItem("Quit", new BMessage(MENU_APP_QUIT), 'Q');
applicationMenu->AddItem(menuItem);
BMenu* editMenu = new BMenu("Edit");
menuBar->AddItem(editMenu);
menuItem = new BMenuItem("Copy Position", NULL, 'C');
editMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Paste Position", NULL, 'V');
editMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
editMenu->AddSeparatorItem();
menuItem = new BMenuItem("Edit Game Data" B_UTF8_ELLIPSIS, NULL, 'E');
editMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
BMenu* viewMenu = new BMenu("View");
menuBar->AddItem(viewMenu);
fFlipBoardMI = new BMenuItem("Flip Board", new BMessage(MENU_VIEW_FLIPBOARD));
viewMenu->AddItem(fFlipBoardMI);
fFlipBoardMI->SetShortcut('R', B_COMMAND_KEY);
fFlipBoardMI->SetMarked(false);
viewMenu->AddSeparatorItem();
fMinIfMenuItem = new BMenuItem("Minimal Interface",
new BMessage(MENU_VIEW_MININTERFACE), '1');
f3DMI = new BMenuItem("3D", new BMessage(MENU_VIEW_3D));
viewMenu->AddItem(f3DMI);
f3DMI->SetShortcut('3', B_COMMAND_KEY);
f3DMI->SetMarked(false);
fFullScrMI = new BMenuItem("Fullscreen",
new BMessage(MENU_VIEW_FULLSCREEN), 'F');
viewMenu->AddItem(fFullScrMI);
fFullScrMI->SetMarked(false);
fFullScrMI->SetEnabled(true);
viewMenu->AddSeparatorItem();
fShowClockMenuItem = new BMenuItem("Show Clock",
new BMessage(MENU_VIEW_SHOWCLOCK));
viewMenu->AddItem(fShowClockMenuItem);
fShowClockMenuItem->SetShortcut('T', B_COMMAND_KEY);
fShowClockMenuItem->SetMarked(true);
fShowMBarMenuItem = new BMenuItem("Show Menubar",
new BMessage(MENU_VIEW_SHOWMENU));
viewMenu->AddItem(fShowMBarMenuItem);
fShowMBarMenuItem->SetShortcut('M', B_COMMAND_KEY);
fShowMBarMenuItem->SetMarked(true);
fSidebarMenuItem = new BMenuItem("Show Sidebar",
new BMessage(MENU_VIEW_SIDEBAR));
viewMenu->AddItem(fSidebarMenuItem);
fSidebarMenuItem->SetShortcut('4', B_COMMAND_KEY);
fSidebarMenuItem->SetMarked(true);
fShowborderMenuItem = new BMenuItem("Show Window Frame",
new BMessage(MENU_VIEW_SHOWBORDER));
viewMenu->AddItem(fShowborderMenuItem);
fShowborderMenuItem->SetShortcut('Y', B_COMMAND_KEY);
fShowborderMenuItem->SetMarked(true);
fAutohidingMenuItem = new BMenuItem("Autohiding",
new BMessage(MENU_VIEW_AUTOHIDING));
viewMenu->AddItem(fAutohidingMenuItem);
fAutohidingMenuItem->SetShortcut('X', B_COMMAND_KEY);
fAutohidingMenuItem->SetMarked(false);
viewMenu->AddSeparatorItem();
fAlwaysOnTopMenuItem = new BMenuItem("Always on top",
new BMessage(MENU_VIEW_ALWAYSONTOP));
viewMenu->AddItem(fAlwaysOnTopMenuItem);
fAlwaysOnTopMenuItem->SetShortcut('A', B_COMMAND_KEY);
fAlwaysOnTopMenuItem->SetMarked(false);
//PostMessage(new BMessage(MENU_VIEW_AUTOHIDING));
BMenu* gameMenu = new BMenu("Game");
menuBar->AddItem(gameMenu);
gameMenu->AddItem(new BMenuItem("New Game",
new BMessage(MENU_GAME_NEWGAME), 'N'));
gameMenu->AddSeparatorItem();
menuItem = new BMenuItem("Move Now", new BMessage(MENU_GAME_MOVENOW), ' ');
gameMenu->AddItem(menuItem);
menuItem->SetEnabled(true);
menuItem = new BMenuItem("Repley" B_UTF8_ELLIPSIS, NULL);
gameMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
gameMenu->AddSeparatorItem();
BMenu* levelsSubMenu = new BMenu("Levels");
levelsSubMenu->SetRadioMode(true);
gameMenu->AddItem(levelsSubMenu);
menuItem = new BMenuItem("Fixed depth" B_UTF8_ELLIPSIS, NULL);
levelsSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Fixed time" B_UTF8_ELLIPSIS, NULL);
levelsSubMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
gameMenu->AddSeparatorItem();
fPauseMenuItem = new BMenuItem("Pause", NULL);
gameMenu->AddItem(fPauseMenuItem);
fPauseMenuItem->SetEnabled(false);
menuItem = new BMenuItem("Offer Draw", NULL);
gameMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
menuItem = new BMenuItem("Resign", NULL, '0');
gameMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
BMenu* engineMenu = new BMenu("Engine");
menuBar->AddItem(engineMenu);
menuItem = new BMenuItem("Change Engine" B_UTF8_ELLIPSIS, NULL);
engineMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
fEngineOffMenuItem = new BMenuItem("Switch off Engine",
new BMessage(MENU_ENGINE_SOENGINE));
engineMenu->AddItem(fEngineOffMenuItem);
fEngineOffMenuItem->SetShortcut('P', B_COMMAND_KEY);
fEngineOffMenuItem->SetEnabled(true);
fEngineOffMenuItem->SetMarked(false);
engineMenu->AddSeparatorItem();
menuItem = new BMenuItem("Engine Management" B_UTF8_ELLIPSIS, NULL);
engineMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
BMenu* toolsMenu = new BMenu("Tools");
menuBar->AddItem(toolsMenu);
menuItem = new BMenuItem("User Info" B_UTF8_ELLIPSIS, NULL);
toolsMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
toolsMenu->AddSeparatorItem();
menuItem = new BMenuItem("Options" B_UTF8_ELLIPSIS, NULL);
toolsMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
toolsMenu->AddSeparatorItem();
menuItem = new BMenuItem("Factory Settings" B_UTF8_ELLIPSIS, NULL);
toolsMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
//BMenu* serverMenu = new BMenu("Server");
//menuBar->AddItem(serverMenu);
fICSConnectMI = new BMenuItem("Connect" B_UTF8_ELLIPSIS,
new BMessage(MENU_SERVER_CONNECT));
// serverMenu->AddItem(fICSConnectMI);
// fICSConnectMI->SetShortcut('S', B_CONTROL_KEY);
BMenu* helpMenu = new BMenu("Help");
menuBar->AddItem(helpMenu);
fMoveAssistantMenuItem = new BMenuItem("Move Assistant",
new BMessage(MENU_HELP_MOVEASSISTANT));
helpMenu->AddItem(fMoveAssistantMenuItem);
fMoveAssistantMenuItem->SetShortcut('J', B_COMMAND_KEY);
fMoveAssistantMenuItem->SetMarked(false);
menuItem = new BMenuItem("Hint" B_UTF8_ELLIPSIS,
new BMessage(MENU_HELP_HINT), 'H');
helpMenu->AddItem(menuItem);
menuItem->SetEnabled(false);
helpMenu->AddSeparatorItem();
menuItem = new BMenuItem("Help" B_UTF8_ELLIPSIS,
new BMessage(MENU_HELP_HELP));
helpMenu->AddItem(menuItem);
menuItem->SetEnabled(true);
helpMenu->AddSeparatorItem();
menuItem = new BMenuItem("About Puri" B_UTF8_ELLIPSIS,
new BMessage(MENU_HELP_ABOUT));
helpMenu->AddItem(menuItem);
return menuBar;
}
RouteWindow::RouteWindow(RouteAppNodeManager* manager)
:
BWindow(s_initFrame, s_windowName, B_DOCUMENT_WINDOW, 0),
m_hScrollBar(0),
m_vScrollBar(0),
m_transportWindow(0),
m_dormantNodeWindow(0),
m_selectedGroupID(0),
m_zoomed(false),
m_zooming(false)
{
BRect b = Bounds();
// initialize the menu bar: add all menus that target this window
BMenuBar* pMenuBar = new BMenuBar(b, "menuBar");
BMenu* pFileMenu = new BMenu("File");
BMenuItem* item = new BMenuItem("Open" B_UTF8_ELLIPSIS,
new BMessage(RouteApp::M_SHOW_OPEN_PANEL), 'O');
item->SetTarget(be_app);
pFileMenu->AddItem(item);
pFileMenu->AddItem(new BSeparatorItem());
item = new BMenuItem("Save nodes" B_UTF8_ELLIPSIS,
new BMessage(RouteApp::M_SHOW_SAVE_PANEL), 'S');
item->SetTarget(be_app);
pFileMenu->AddItem(item);
pFileMenu->AddItem(new BSeparatorItem());
pFileMenu->AddItem(new BMenuItem("About Cortex/Route" B_UTF8_ELLIPSIS,
new BMessage(B_ABOUT_REQUESTED)));
pFileMenu->AddItem(new BSeparatorItem());
pFileMenu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED)));
pMenuBar->AddItem(pFileMenu);
AddChild(pMenuBar);
// build the routing view
BRect rvBounds = b;
rvBounds.top = pMenuBar->Frame().bottom+1;
rvBounds.right -= B_V_SCROLL_BAR_WIDTH;
rvBounds.bottom -= B_H_SCROLL_BAR_HEIGHT;
m_routingView = new MediaRoutingView(manager, rvBounds, "routingView");
BRect hsBounds = rvBounds;
hsBounds.left = rvBounds.left + 199;
hsBounds.top = hsBounds.bottom + 1;
hsBounds.right++;
hsBounds.bottom = b.bottom + 1;
m_hScrollBar = new BScrollBar(hsBounds, "hScrollBar", m_routingView,
0, 0, B_HORIZONTAL);
AddChild(m_hScrollBar);
BRect vsBounds = rvBounds;
vsBounds.left = vsBounds.right + 1;
vsBounds.top--;
vsBounds.right = b.right + 1;
vsBounds.bottom++;
m_vScrollBar = new BScrollBar(vsBounds, "vScrollBar", m_routingView,
0, 0, B_VERTICAL);
AddChild(m_vScrollBar);
BRect svBounds = rvBounds;
svBounds.left -= 1;
svBounds.right = hsBounds.left - 1;
svBounds.top = svBounds.bottom + 1;
svBounds.bottom = b.bottom + 1;
m_statusView = new StatusView(svBounds, manager, m_hScrollBar);
AddChild(m_statusView);
AddChild(m_routingView);
float minWidth, maxWidth, minHeight, maxHeight;
GetSizeLimits(&minWidth, &maxWidth, &minHeight, &maxHeight);
minWidth = m_statusView->Frame().Width() + 6 * B_V_SCROLL_BAR_WIDTH;
minHeight = 6 * B_H_SCROLL_BAR_HEIGHT;
SetSizeLimits(minWidth, maxWidth, minHeight, maxHeight);
// construct the Window menu
BMenu* windowMenu = new BMenu("Window");
m_transportWindowItem = new BMenuItem(
"Show transport",
new BMessage(M_TOGGLE_TRANSPORT_WINDOW));
windowMenu->AddItem(m_transportWindowItem);
m_dormantNodeWindowItem = new BMenuItem(
"Show add-ons",
new BMessage(M_TOGGLE_DORMANT_NODE_WINDOW));
windowMenu->AddItem(m_dormantNodeWindowItem);
windowMenu->AddItem(new BSeparatorItem());
m_pullPalettesItem = new BMenuItem(
"Pull palettes",
new BMessage(M_TOGGLE_PULLING_PALETTES));
windowMenu->AddItem(m_pullPalettesItem);
pMenuBar->AddItem(windowMenu);
// create the dormant-nodes palette
_toggleDormantNodeWindow();
// display group inspector
_toggleTransportWindow();
}
VideoWindow::VideoWindow(BRect frame, const char* title, window_type type,
uint32 flags, port_id* consumerPort)
:
BWindow(frame, title, type, flags),
fPortPtr(consumerPort),
fView(NULL),
fVideoView(NULL)
{
fFtpInfo.port = 0;
fFtpInfo.rate = 0x7fffffff;
fFtpInfo.imageFormat = 0;
fFtpInfo.translator = 0;
fFtpInfo.passiveFtp = true;
fFtpInfo.uploadClient = 0;
strcpy(fFtpInfo.fileNameText, "filename");
strcpy(fFtpInfo.serverText, "server");
strcpy(fFtpInfo.loginText, "login");
strcpy(fFtpInfo.passwordText, "password");
strcpy(fFtpInfo.directoryText, "directory");
_SetUpSettings("codycam", "");
BMenuBar* menuBar = new BMenuBar(BRect(0, 0, 0, 0), "menu bar");
BMenuItem* menuItem;
BMenu* menu = new BMenu("File");
menuItem = new BMenuItem("Video settings", new BMessage(msg_video), 'P');
menuItem->SetTarget(be_app);
menu->AddItem(menuItem);
menu->AddSeparatorItem();
menuItem = new BMenuItem("Start video", new BMessage(msg_start), 'A');
menuItem->SetTarget(be_app);
menu->AddItem(menuItem);
menuItem = new BMenuItem("Stop video", new BMessage(msg_stop), 'O');
menuItem->SetTarget(be_app);
menu->AddItem(menuItem);
menu->AddSeparatorItem();
menuItem = new BMenuItem("About Codycam" B_UTF8_ELLIPSIS,
new BMessage(msg_about), 'B');
menuItem->SetTarget(be_app);
menu->AddItem(menuItem);
menu->AddSeparatorItem();
menuItem = new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q');
menuItem->SetTarget(be_app);
menu->AddItem(menuItem);
menuBar->AddItem(menu);
/* give it a gray background view */
fView = new BView("Background View", B_WILL_DRAW);
fView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
/* add some controls */
_BuildCaptureControls(fView);
SetLayout(new BGroupLayout(B_VERTICAL));
AddChild(menuBar);
AddChild(fView);
Show();
}
status_t
InterfaceHardwareView::Update()
{
// Populate fields with current settings
if (fSettings->HasLink()) {
if (fSettings->IsWireless()) {
BString network = fSettings->WirelessNetwork();
network.Prepend(" (");
network.Prepend(B_TRANSLATE("connected"));
network.Append(")");
fStatusField->SetText(network.String());
} else {
fStatusField->SetText(B_TRANSLATE("connected"));
}
} else
fStatusField->SetText(B_TRANSLATE("disconnected"));
fMacAddressField->SetText(fSettings->HardwareAddress());
// TODO : Find how to get link speed
fLinkSpeedField->SetText("100 Mb/s");
// Update Link stats
ifreq_stats stats;
char buffer[100];
fSettings->Stats(&stats);
string_for_size(stats.send.bytes, buffer, sizeof(buffer));
fLinkTxField->SetText(buffer);
string_for_size(stats.receive.bytes, buffer, sizeof(buffer));
fLinkRxField->SetText(buffer);
// TODO move the wireless info to a separate tab. We should have a
// BListView of available networks, rather than a menu, to make them more
// readable and easier to browse and select.
if (fNetworkMenuField->IsHidden(fNetworkMenuField)
&& fSettings->IsWireless()) {
fNetworkMenuField->Show();
} else if (!fNetworkMenuField->IsHidden(fNetworkMenuField)
&& !fSettings->IsWireless()) {
fNetworkMenuField->Hide();
}
if (fSettings->IsWireless()) {
// Rebuild network menu
BMenu* menu = fNetworkMenuField->Menu();
menu->RemoveItems(0, menu->CountItems(), true);
std::set<BNetworkAddress> associated;
BNetworkAddress address;
uint32 cookie = 0;
while (fSettings->GetNextAssociatedNetwork(cookie, address) == B_OK)
associated.insert(address);
wireless_network network;
int32 count = 0;
cookie = 0;
while (fSettings->GetNextNetwork(cookie, network) == B_OK) {
BMessage* message = new BMessage(kMsgNetwork);
message->AddString("device", fSettings->Name());
message->AddString("name", network.name);
BMenuItem* item = new WirelessNetworkMenuItem(network.name,
network.signal_strength,
network.authentication_mode, message);
if (associated.find(network.address) != associated.end())
item->SetMarked(true);
menu->AddItem(item);
count++;
}
if (count == 0) {
BMenuItem* item = new BMenuItem(
B_TRANSLATE("<no wireless networks found>"), NULL);
item->SetEnabled(false);
menu->AddItem(item);
} else {
BMenuItem* item = new BMenuItem(
B_TRANSLATE("Choose automatically"), NULL);
if (menu->FindMarked() == NULL)
item->SetMarked(true);
menu->AddItem(item, 0);
menu->AddItem(new BSeparatorItem(), 1);
}
menu->SetTargetForItems(this);
}
fRenegotiate->SetEnabled(!fSettings->IsDisabled());
fOnOff->SetLabel(fSettings->IsDisabled() ? "Enable" : "Disable");
return B_OK;
}
SudokuWindow::SudokuWindow()
:
BWindow(BRect(-1, -1, 400, 420), B_TRANSLATE_SYSTEM_NAME("Sudoku"),
B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE),
fGenerator(NULL),
fStoredState(NULL),
fExportFormat(kExportAsText)
{
BMessage settings;
_LoadSettings(settings);
BRect frame;
if (settings.FindRect("window frame", &frame) == B_OK) {
MoveTo(frame.LeftTop());
ResizeTo(frame.Width(), frame.Height());
frame.OffsetTo(B_ORIGIN);
} else {
float scaling = std::max(1.0f, be_plain_font->Size() / 12.0f);
ResizeTo(Frame().Width() * scaling, Frame().Height() * scaling);
frame = Bounds();
}
MoveOnScreen();
if (settings.HasMessage("stored state")) {
fStoredState = new BMessage;
if (settings.FindMessage("stored state", fStoredState) != B_OK) {
delete fStoredState;
fStoredState = NULL;
}
}
int32 level = 0;
settings.FindInt32("level", &level);
// create GUI
BMenuBar* menuBar = new BMenuBar(Bounds(), "menu");
AddChild(menuBar);
frame.top = menuBar->Frame().bottom;
BView* top = new BView(frame, NULL, B_FOLLOW_ALL, B_WILL_DRAW);
top->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
AddChild(top);
fSudokuView = new SudokuView(
top->Bounds().InsetByCopy(10, 10).OffsetToSelf(0, 0),
"sudoku view", settings, B_FOLLOW_NONE);
CenteredViewContainer* container = new CenteredViewContainer(fSudokuView,
top->Bounds().InsetByCopy(10, 10),
"center", B_FOLLOW_ALL);
container->SetHighColor(top->ViewColor());
top->AddChild(container);
// add menu
// "File" menu
BMenu* menu = new BMenu(B_TRANSLATE("File"));
fNewMenu = new BMenu(B_TRANSLATE("New"));
menu->AddItem(new BMenuItem(fNewMenu, new BMessage(kMsgGenerateSudoku)));
fNewMenu->Superitem()->SetShortcut('N', B_COMMAND_KEY);
BMessage* message = new BMessage(kMsgGenerateSudoku);
message->AddInt32("level", kEasyLevel);
fNewMenu->AddItem(new BMenuItem(B_TRANSLATE("Easy"), message));
message = new BMessage(kMsgGenerateSudoku);
message->AddInt32("level", kAdvancedLevel);
fNewMenu->AddItem(new BMenuItem(B_TRANSLATE("Advanced"), message));
message = new BMessage(kMsgGenerateSudoku);
message->AddInt32("level", kHardLevel);
fNewMenu->AddItem(new BMenuItem(B_TRANSLATE("Hard"), message));
fNewMenu->AddSeparatorItem();
fNewMenu->AddItem(new BMenuItem(B_TRANSLATE("Blank"),
new BMessage(kMsgNewBlank)));
menu->AddItem(new BMenuItem(B_TRANSLATE("Start again"),
new BMessage(kMsgStartAgain)));
menu->AddSeparatorItem();
BMenu* recentsMenu = BRecentFilesList::NewFileListMenu(
B_TRANSLATE("Open file" B_UTF8_ELLIPSIS), NULL, NULL, this, 10, false,
NULL, kSignature);
BMenuItem *item;
menu->AddItem(item = new BMenuItem(recentsMenu,
new BMessage(kMsgOpenFilePanel)));
item->SetShortcut('O', B_COMMAND_KEY);
menu->AddSeparatorItem();
BMenu* subMenu = new BMenu(B_TRANSLATE("Export as" B_UTF8_ELLIPSIS));
message = new BMessage(kMsgExportAs);
message->AddInt32("as", kExportAsText);
subMenu->AddItem(new BMenuItem(B_TRANSLATE("Text"), message));
message= new BMessage(kMsgExportAs);
message->AddInt32("as", kExportAsHTML);
subMenu->AddItem(new BMenuItem(B_TRANSLATE("HTML"), message));
menu->AddItem(subMenu);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Copy"),
new BMessage(B_COPY), 'C'));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
menu->SetTargetForItems(this);
item->SetTarget(be_app);
menuBar->AddItem(menu);
// "View" menu
menu = new BMenu(B_TRANSLATE("View"));
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Mark invalid values"),
new BMessage(kMsgMarkInvalid)));
if ((fSudokuView->HintFlags() & kMarkInvalid) != 0)
item->SetMarked(true);
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Mark valid hints"),
new BMessage(kMsgMarkValidHints)));
if ((fSudokuView->HintFlags() & kMarkValidHints) != 0)
item->SetMarked(true);
menu->SetTargetForItems(this);
menuBar->AddItem(menu);
// "Help" menu
menu = new BMenu(B_TRANSLATE("Help"));
menu->AddItem(fUndoItem = new BMenuItem(B_TRANSLATE("Undo"),
new BMessage(B_UNDO), 'Z'));
fUndoItem->SetEnabled(false);
menu->AddItem(fRedoItem = new BMenuItem(B_TRANSLATE("Redo"),
new BMessage(B_REDO), 'Z', B_SHIFT_KEY));
fRedoItem->SetEnabled(false);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Snapshot current"),
new BMessage(kMsgStoreState)));
menu->AddItem(fRestoreStateItem = new BMenuItem(
B_TRANSLATE("Restore snapshot"), new BMessage(kMsgRestoreState)));
fRestoreStateItem->SetEnabled(fStoredState != NULL);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Set all hints"),
new BMessage(kMsgSetAllHints)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Solve"),
new BMessage(kMsgSolveSudoku)));
menu->AddItem(new BMenuItem(B_TRANSLATE("Solve single field"),
new BMessage(kMsgSolveSingle)));
menu->SetTargetForItems(fSudokuView);
menuBar->AddItem(menu);
fOpenPanel = new BFilePanel(B_OPEN_PANEL);
fOpenPanel->SetTarget(this);
fSavePanel = new BFilePanel(B_SAVE_PANEL);
fSavePanel->SetTarget(this);
_SetLevel(level);
fSudokuView->StartWatching(this, kUndoRedoChanged);
// we like to know whenever the undo/redo state changes
fProgressWindow = new ProgressWindow(this,
new BMessage(kMsgAbortSudokuGenerator));
if (fSudokuView->Field()->IsEmpty())
PostMessage(kMsgGenerateSudoku);
}
BPopUpMenu*
DeskbarView::_BuildMenu()
{
BPopUpMenu* menu = new BPopUpMenu(B_EMPTY_STRING, false, false);
menu->SetFont(be_plain_font);
menu->AddItem(new BMenuItem(B_TRANSLATE("Create new message"
B_UTF8_ELLIPSIS), new BMessage(MD_OPEN_NEW)));
menu->AddSeparatorItem();
BMessenger tracker(kTrackerSignature);
BNavMenu* navMenu;
BMenuItem* item;
BMessage* msg;
entry_ref ref;
BPath path;
find_directory(B_USER_SETTINGS_DIRECTORY, &path);
path.Append("Mail/Menu Links");
BDirectory directory;
if (_CreateMenuLinks(directory, path)) {
int32 count = 0;
while (directory.GetNextRef(&ref) == B_OK) {
count++;
path.SetTo(&ref);
// the true here dereferences the symlinks all the way :)
BEntry entry(&ref, true);
// do we want to use the NavMenu, or just an ordinary BMenuItem?
// we are using the NavMenu only for directories and queries
bool useNavMenu = false;
if (entry.InitCheck() == B_OK) {
if (entry.IsDirectory())
useNavMenu = true;
else if (entry.IsFile()) {
// Files should use the BMenuItem unless they are queries
char mimeString[B_MIME_TYPE_LENGTH];
BNode node(&entry);
BNodeInfo info(&node);
if (info.GetType(mimeString) == B_OK
&& strcmp(mimeString, "application/x-vnd.Be-query")
== 0)
useNavMenu = true;
}
// clobber the existing ref only if the symlink derefernces
// completely, otherwise we'll stick with what we have
entry.GetRef(&ref);
}
msg = new BMessage(B_REFS_RECEIVED);
msg->AddRef("refs", &ref);
if (useNavMenu) {
item = new BMenuItem(navMenu = new BNavMenu(path.Leaf(),
B_REFS_RECEIVED, tracker), msg);
navMenu->SetNavDir(&ref);
} else
item = new BMenuItem(path.Leaf(), msg);
menu->AddItem(item);
if (entry.InitCheck() != B_OK)
item->SetEnabled(false);
}
if (count > 0)
menu->AddSeparatorItem();
}
// Hack for R5's buggy Query Notification
#ifdef HAIKU_TARGET_PLATFORM_BEOS
menu->AddItem(new BMenuItem(B_TRANSLATE("Refresh New Mail Count"),
new BMessage(MD_REFRESH_QUERY)));
#endif
// The New E-mail query
if (fNewMessages > 0) {
static BMessageFormat format(B_TRANSLATE(
"{0, plural, one{# new message} other{# new messages}}"));
BString string;
format.Format(string, fNewMessages);
_GetNewQueryRef(ref);
item = new BMenuItem(navMenu = new BNavMenu(string.String(),
B_REFS_RECEIVED, BMessenger(kTrackerSignature)),
msg = new BMessage(B_REFS_RECEIVED));
msg->AddRef("refs", &ref);
navMenu->SetNavDir(&ref);
menu->AddItem(item);
} else {
menu->AddItem(item = new BMenuItem(B_TRANSLATE("No new messages"),
NULL));
item->SetEnabled(false);
}
BMailAccounts accounts;
if ((modifiers() & B_SHIFT_KEY) != 0) {
BMenu *accountMenu = new BMenu(B_TRANSLATE("Check for mails only"));
BFont font;
menu->GetFont(&font);
accountMenu->SetFont(&font);
for (int32 i = 0; i < accounts.CountAccounts(); i++) {
BMailAccountSettings* account = accounts.AccountAt(i);
BMessage* message = new BMessage(MD_CHECK_FOR_MAILS);
message->AddInt32("account", account->AccountID());
accountMenu->AddItem(new BMenuItem(account->Name(), message));
}
if (accounts.CountAccounts() == 0) {
item = new BMenuItem(B_TRANSLATE("<no accounts>"), NULL);
item->SetEnabled(false);
accountMenu->AddItem(item);
}
accountMenu->SetTargetForItems(this);
menu->AddItem(new BMenuItem(accountMenu,
new BMessage(MD_CHECK_FOR_MAILS)));
// Not used:
// menu->AddItem(new BMenuItem(B_TRANSLATE("Check For Mails Only"),
// new BMessage(MD_CHECK_FOR_MAILS)));
menu->AddItem(new BMenuItem(B_TRANSLATE("Send pending mails"),
new BMessage(MD_SEND_MAILS)));
} else {
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Check for mail now"),
new BMessage(MD_CHECK_SEND_NOW)));
if (accounts.CountAccounts() == 0)
item->SetEnabled(false);
}
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Settings" B_UTF8_ELLIPSIS),
new BMessage(MD_OPEN_PREFS)));
if (modifiers() & B_SHIFT_KEY) {
menu->AddItem(new BMenuItem(B_TRANSLATE("Shutdown mail services"),
new BMessage(B_QUIT_REQUESTED)));
}
// Reset Item Targets (only those which aren't already set)
for (int32 i = menu->CountItems(); i-- > 0;) {
item = menu->ItemAt(i);
if (item != NULL && (msg = item->Message()) != NULL) {
if (msg->what == B_REFS_RECEIVED)
item->SetTarget(tracker);
else
item->SetTarget(this);
}
}
return menu;
}
CharacterWindow::CharacterWindow()
:
BWindow(BRect(100, 100, 700, 550), B_TRANSLATE_SYSTEM_NAME("CharacterMap"),
B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE
| B_AUTO_UPDATE_SIZE_LIMITS)
{
BMessage settings;
_LoadSettings(settings);
BRect frame;
if (settings.FindRect("window frame", &frame) == B_OK) {
MoveTo(frame.LeftTop());
ResizeTo(frame.Width(), frame.Height());
}
// create GUI
SetLayout(new BGroupLayout(B_VERTICAL));
BMenuBar* menuBar = new BMenuBar("menu");
fFilterControl = new BTextControl(B_TRANSLATE("Filter:"), NULL, NULL);
fFilterControl->SetModificationMessage(new BMessage(kMsgFilterChanged));
BButton* clearButton = new BButton("clear", B_TRANSLATE("Clear"),
new BMessage(kMsgClearFilter));
fUnicodeBlockView = new UnicodeBlockView("unicodeBlocks");
fUnicodeBlockView->SetSelectionMessage(
new BMessage(kMsgUnicodeBlockSelected));
BScrollView* unicodeScroller = new BScrollView("unicodeScroller",
fUnicodeBlockView, 0, false, true);
fCharacterView = new CharacterView("characters");
fCharacterView->SetTarget(this, kMsgCharacterChanged);
fGlyphView = new BStringView("glyph", "");
fGlyphView->SetExplicitMaxSize(BSize(B_SIZE_UNSET,
fGlyphView->PreferredSize().Height()));
// TODO: have a context object shared by CharacterView/UnicodeBlockView
bool show;
if (settings.FindBool("show private blocks", &show) == B_OK) {
fCharacterView->ShowPrivateBlocks(show);
fUnicodeBlockView->ShowPrivateBlocks(show);
}
if (settings.FindBool("show contained blocks only", &show) == B_OK) {
fCharacterView->ShowContainedBlocksOnly(show);
fUnicodeBlockView->ShowPrivateBlocks(show);
}
const char* family;
const char* style;
if (settings.FindString("font family", &family) == B_OK
&& settings.FindString("font style", &style) == B_OK) {
_SetFont(family, style);
}
int32 fontSize;
if (settings.FindInt32("font size", &fontSize) == B_OK) {
BFont font = fCharacterView->CharacterFont();
if (fontSize < kMinFontSize)
fontSize = kMinFontSize;
else if (fontSize > kMaxFontSize)
fontSize = kMaxFontSize;
font.SetSize(fontSize);
fCharacterView->SetCharacterFont(font);
} else
fontSize = (int32)fCharacterView->CharacterFont().Size();
BScrollView* characterScroller = new BScrollView("characterScroller",
fCharacterView, 0, false, true);
fFontSizeSlider = new FontSizeSlider("fontSizeSlider",
B_TRANSLATE("Font size:"),
new BMessage(kMsgFontSizeChanged), kMinFontSize, kMaxFontSize);
fFontSizeSlider->SetValue(fontSize);
fCodeView = new BStringView("code", "-");
fCodeView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED,
fCodeView->PreferredSize().Height()));
AddChild(BGroupLayoutBuilder(B_VERTICAL)
.Add(menuBar)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 10)//BSplitLayoutBuilder()
.Add(BGroupLayoutBuilder(B_VERTICAL, 10)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 10)
.Add(fFilterControl)
.Add(clearButton))
.Add(unicodeScroller))
.Add(BGroupLayoutBuilder(B_VERTICAL, 10)
.Add(characterScroller)
.Add(fFontSizeSlider)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 0)
.Add(fGlyphView)
.Add(fCodeView)))
.SetInsets(10, 10, 10, 10)));
// Add menu
// "File" menu
BMenu* menu = new BMenu(B_TRANSLATE("File"));
BMenuItem* item;
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
menu->SetTargetForItems(this);
menuBar->AddItem(menu);
menu = new BMenu(B_TRANSLATE("View"));
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Show private blocks"),
new BMessage(kMsgPrivateBlocks)));
item->SetMarked(fCharacterView->IsShowingPrivateBlocks());
// TODO: this feature is not yet supported by Haiku!
#if 0
menu->AddItem(item = new BMenuItem("Only show blocks contained in font",
new BMessage(kMsgContainedBlocks)));
item->SetMarked(fCharacterView->IsShowingContainedBlocksOnly());
#endif
menuBar->AddItem(menu);
menuBar->AddItem(_CreateFontMenu());
AddCommonFilter(new EscapeMessageFilter(kMsgClearFilter));
AddCommonFilter(new RedirectUpAndDownFilter(fUnicodeBlockView));
// TODO: why is this needed?
fUnicodeBlockView->SetTarget(this);
fFilterControl->MakeFocus();
}
void
QPopupMenu::AddPersonItem(const entry_ref *ref, ino_t node, BString &name,
BString &email, const char *attr, BMenu *groupMenu, BMenuItem *superItem)
{
BString label;
BString sortKey;
// For alphabetical order sorting, usually last name.
// if we have no Name, just use the email address
if (name.Length() == 0) {
label = email;
sortKey = email;
} else {
// otherwise, pretty-format it
label << name << " (" << email << ")";
// Extract the last name (last word in the name),
// removing trailing and leading spaces.
const char *nameStart = name.String();
const char *string = nameStart + strlen(nameStart) - 1;
const char *wordEnd;
while (string >= nameStart && isspace(*string))
string--;
wordEnd = string + 1; // Points to just after last word.
while (string >= nameStart && !isspace(*string))
string--;
string++; // Point to first letter in the word.
if (wordEnd > string)
sortKey.SetTo(string, wordEnd - string);
else // Blank name, pretend that the last name is after it.
string = nameStart + strlen(nameStart);
// Append the first names to the end, so that people with the same last
// name get sorted by first name. Note no space between the end of the
// last name and the start of the first names, but that shouldn't
// matter for sorting.
sortKey.Append(nameStart, string - nameStart);
}
// The target (a TTextControl) will examine all the People files specified
// and add the emails and names to the string it is displaying (same code
// is used for drag and drop of People files).
BMessage *msg = new BMessage(B_SIMPLE_DATA);
msg->AddRef("refs", ref);
msg->AddInt64("node", node);
if (attr) // For nonstandard e-mail attributes, like META:email3
msg->AddString("attr", attr);
msg->AddString("sortkey", sortKey);
BMenuItem *newItem = new BMenuItem(label.String(), msg);
if (fTargetHandler)
newItem->SetTarget(fTargetHandler);
// If no group, just add it to ourself; else add it to group menu
BMenu *parentMenu = groupMenu ? groupMenu : this;
if (groupMenu) {
// Add ref to group super item.
BMessage *superMsg = superItem->Message();
superMsg->AddRef("refs", ref);
}
// Add it to the appropriate menu. Use alphabetical order by sortKey to
// insert it in the right spot (a dumb linear search so this will be slow).
// Start searching from the end of the menu, since the main menu includes
// all the groups at the top and we don't want to mix it in with them.
// Thus the search starts at the bottom and ends when we hit a separator
// line or the top of the menu.
int32 index = parentMenu->CountItems();
while (index-- > 0) {
BMenuItem *item = parentMenu->ItemAt(index);
if (item == NULL || dynamic_cast<BSeparatorItem *>(item) != NULL)
break;
BMessage *message = item->Message();
BString key;
// Stop when testKey < sortKey.
if (message != NULL
&& message->FindString("sortkey", &key) == B_OK
&& ICompare(key, sortKey) < 0)
break;
}
if (!parentMenu->AddItem(newItem, index + 1)) {
fprintf (stderr, "QPopupMenu::AddPersonItem: Unable to add menu "
"item \"%s\" at index %ld.\n", sortKey.String(), index + 1);
delete newItem;
}
}
void
TeamsWindow::_Init()
{
BMessage settings;
_LoadSettings(settings);
BRect frame;
if (settings.FindRect("teams window frame", &frame) == B_OK) {
MoveTo(frame.LeftTop());
ResizeTo(frame.Width(), frame.Height());
}
BMenu* connectionMenu = new BMenu("Connection");
ObjectDeleter<BMenu> menuDeleter(connectionMenu);
connectionMenu->SetLabelFromMarked(true);
TargetHostInterfaceRoster* roster = TargetHostInterfaceRoster::Default();
for (int32 i = 0; i < roster->CountActiveInterfaces(); i++) {
TargetHostInterface* interface = roster->ActiveInterfaceAt(i);
BMenuItem* item = new BMenuItem(interface->GetTargetHost()->Name(),
new BMessage(MSG_SWITCH_TARGET_CONNECTION));
if (item->Message()->AddPointer("interface", interface) != B_OK) {
delete item;
throw std::bad_alloc();
}
if (interface->IsLocal()) {
item->SetMarked(true);
fTargetHostInterface = interface;
}
connectionMenu->AddItem(item);
}
BGroupLayout* connectionLayout = NULL;
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_DEFAULT_SPACING)
.GetLayout(&connectionLayout)
.Add(fConnectionField = new BMenuField("Connected to:",
connectionMenu))
.AddGlue()
.Add(fCreateConnectionButton = new BButton("Create new connection"
B_UTF8_ELLIPSIS, new BMessage(
MSG_SHOW_CONNECTION_CONFIG_WINDOW)))
.End()
.Add(fTeamsListView = new TeamsListView("TeamsList"))
.SetInsets(1.0f, 1.0f, 1.0f, 5.0f)
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_DEFAULT_SPACING)
.Add(fAttachTeamButton = new BButton("Attach", new BMessage(
MSG_DEBUG_THIS_TEAM)))
.AddGlue()
.Add(fCreateTeamButton = new BButton("Start new team"
B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_START_TEAM_WINDOW)))
.Add(fLoadCoreButton = new BButton("Load core" B_UTF8_ELLIPSIS,
new BMessage(MSG_LOAD_CORE_TEAM)))
.End()
.End();
connectionLayout->SetVisible(false);
menuDeleter.Detach();
AddListener(fTeamsListView);
connectionMenu->SetTargetForItems(this);
fTeamsListView->SetInvocationMessage(new BMessage(MSG_DEBUG_THIS_TEAM));
fTeamsListView->SetSelectionMessage(new BMessage(
MSG_TEAM_SELECTION_CHANGED));
fAttachTeamButton->SetEnabled(false);
fCreateTeamButton->SetTarget(this);
fLoadCoreButton->SetTarget(this);
fCreateConnectionButton->SetTarget(be_app);
_NotifySelectedInterfaceChanged(fTargetHostInterface);
}
void
TeamWindow::_Init()
{
BScrollView* sourceScrollView;
BLayoutBuilder::Group<>(this, B_VERTICAL)
.Add(fMenuBar = new BMenuBar("Menu"))
.AddSplit(B_VERTICAL, 3.0f)
.GetSplitView(&fFunctionSplitView)
.SetInsets(4.0f, 4.0f, 4.0f, 4.0f)
.Add(fTabView = new BTabView("tab view"), 0.4f)
.AddGroup(B_VERTICAL, 4.0f)
.AddGroup(B_HORIZONTAL, 4.0f)
.Add(fRunButton = new BButton("Run"))
.Add(fStepOverButton = new BButton("Step Over"))
.Add(fStepIntoButton = new BButton("Step Into"))
.Add(fStepOutButton = new BButton("Step Out"))
.AddGlue()
.End()
.Add(fSourcePathView = new BStringView(
"source path",
"Source path unavailable."), 4.0f)
.AddSplit(B_HORIZONTAL, 3.0f)
.GetSplitView(&fSourceSplitView)
.Add(sourceScrollView = new BScrollView("source scroll",
NULL, 0, true, true), 3.0f)
.Add(fLocalsTabView = new BTabView("locals view"))
.End()
.End()
.End();
// add source view
sourceScrollView->SetTarget(fSourceView = SourceView::Create(fTeam, this));
// add threads tab
BSplitView* threadGroup = new BSplitView(B_HORIZONTAL);
threadGroup->SetName("Threads");
fTabView->AddTab(threadGroup);
BLayoutBuilder::Split<>(threadGroup)
.GetSplitView(&fThreadSplitView)
.Add(fThreadListView = ThreadListView::Create(fTeam, this))
.Add(fStackTraceView = StackTraceView::Create(this));
// add images tab
BSplitView* imagesGroup = new BSplitView(B_HORIZONTAL);
imagesGroup->SetName("Images");
fTabView->AddTab(imagesGroup);
BLayoutBuilder::Split<>(imagesGroup)
.GetSplitView(&fImageSplitView)
.Add(fImageListView = ImageListView::Create(fTeam, this))
.Add(fImageFunctionsView = ImageFunctionsView::Create(this));
// add breakpoints tab
BGroupView* breakpointsGroup = new BGroupView(B_HORIZONTAL, 4.0f);
breakpointsGroup->SetName("Breakpoints");
fTabView->AddTab(breakpointsGroup);
BLayoutBuilder::Group<>(breakpointsGroup)
.SetInsets(4.0f, 4.0f, 4.0f, 4.0f)
.Add(fBreakpointsView = BreakpointsView::Create(fTeam, this));
// add local variables tab
BView* tab = fVariablesView = VariablesView::Create(this);
fLocalsTabView->AddTab(tab);
// add registers tab
tab = fRegistersView = RegistersView::Create(fTeam->GetArchitecture());
fLocalsTabView->AddTab(tab);
fRunButton->SetMessage(new BMessage(MSG_THREAD_RUN));
fStepOverButton->SetMessage(new BMessage(MSG_THREAD_STEP_OVER));
fStepIntoButton->SetMessage(new BMessage(MSG_THREAD_STEP_INTO));
fStepOutButton->SetMessage(new BMessage(MSG_THREAD_STEP_OUT));
fRunButton->SetTarget(this);
fStepOverButton->SetTarget(this);
fStepIntoButton->SetTarget(this);
fStepOutButton->SetTarget(this);
fSourcePathView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
BMessageFilter* filter = new(std::nothrow) PathViewMessageFilter(
BMessenger(this));
if (filter != NULL)
fSourcePathView->AddFilter(filter);
// add menus and menu items
BMenu* menu = new BMenu("File");
fMenuBar->AddItem(menu);
BMenuItem* item = new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED),
'Q');
menu->AddItem(item);
item->SetTarget(this);
menu = new BMenu("Edit");
fMenuBar->AddItem(menu);
item = new BMenuItem("Copy", new BMessage(B_COPY), 'C');
menu->AddItem(item);
item->SetTarget(this);
item = new BMenuItem("Select All", new BMessage(B_SELECT_ALL), 'A');
menu->AddItem(item);
item->SetTarget(this);
menu = new BMenu("Tools");
fMenuBar->AddItem(menu);
item = new BMenuItem("Inspect Memory",
new BMessage(MSG_SHOW_INSPECTOR_WINDOW), 'I');
menu->AddItem(item);
item->SetTarget(this);
AutoLocker< ::Team> locker(fTeam);
_UpdateRunButtons();
}
AttributeWindow::AttributeWindow(FileTypesWindow* target, BMimeType& mimeType,
AttributeItem* attributeItem)
:
BWindow(BRect(100, 100, 350, 200), B_TRANSLATE("Attribute"),
B_MODAL_WINDOW_LOOK, B_MODAL_SUBSET_WINDOW_FEEL,
B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS | B_ASYNCHRONOUS_CONTROLS),
fTarget(target),
fMimeType(mimeType.Type())
{
float padding = be_control_look->DefaultItemSpacing();
if (attributeItem != NULL)
fAttribute = *attributeItem;
fPublicNameControl = new BTextControl(B_TRANSLATE("Attribute name:"),
fAttribute.PublicName(), NULL);
fPublicNameControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fPublicNameControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fAttributeControl = new BTextControl(B_TRANSLATE("Internal name:"),
fAttribute.Name(), NULL);
fAttributeControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fAttributeControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of an attribute
BTextView* textView = fAttributeControl->TextView();
const char* disallowedCharacters = "/";
for (int32 i = 0; disallowedCharacters[i]; i++) {
textView->DisallowChar(disallowedCharacters[i]);
}
fTypeMenu = new BPopUpMenu("type");
BMenuItem* item = NULL;
for (int32 i = 0; kTypeMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgTypeChosen);
message->AddInt32("type", kTypeMap[i].type);
item = new BMenuItem(kTypeMap[i].name, message);
fTypeMenu->AddItem(item);
if (kTypeMap[i].type == fAttribute.Type())
item->SetMarked(true);
}
BMenuField* typeMenuField = new BMenuField("types" , B_TRANSLATE("Type:"),
fTypeMenu);
typeMenuField->SetAlignment(B_ALIGN_RIGHT);
// we must set the color manually when adding a menuField directly
// into a window.
typeMenuField->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
typeMenuField->SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fVisibleCheckBox = new BCheckBox("visible", B_TRANSLATE("Visible"),
new BMessage(kMsgVisibilityChanged));
fVisibleCheckBox->SetValue(fAttribute.Visible());
BMenu* menu = new BPopUpMenu("display as");
for (int32 i = 0; kDisplayAsMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgDisplayAsChosen);
if (kDisplayAsMap[i].identifier != NULL) {
message->AddString("identifier", kDisplayAsMap[i].identifier);
for (int32 j = 0; kDisplayAsMap[i].supported[j]; j++) {
message->AddInt32("supports", kDisplayAsMap[i].supported[j]);
}
}
item = new BMenuItem(kDisplayAsMap[i].name, message);
menu->AddItem(item);
if (compare_display_as(kDisplayAsMap[i].identifier,
fAttribute.DisplayAs()))
item->SetMarked(true);
}
fDisplayAsMenuField = new BMenuField("display as",
B_TRANSLATE_COMMENT("Display as:",
"Tracker offers different display modes for attributes."), menu);
fDisplayAsMenuField->SetAlignment(B_ALIGN_RIGHT);
fEditableCheckBox = new BCheckBox("editable",
B_TRANSLATE_COMMENT("Editable",
"If Tracker allows to edit this attribute."),
new BMessage(kMsgAttributeUpdated));
fEditableCheckBox->SetValue(fAttribute.Editable());
fSpecialControl = new BTextControl(B_TRANSLATE("Special:"),
display_as_parameter(fAttribute.DisplayAs()), NULL);
fSpecialControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fSpecialControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
fSpecialControl->SetEnabled(false);
char text[64];
snprintf(text, sizeof(text), "%ld", fAttribute.Width());
fWidthControl = new BTextControl(B_TRANSLATE_COMMENT("Width:",
"Default column width in Tracker for this attribute."),
text, NULL);
fWidthControl->SetModificationMessage(
new BMessage(kMsgAttributeUpdated));
fWidthControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
// filter out invalid characters that can't be part of a width
textView = fWidthControl->TextView();
for (int32 i = 0; i < 256; i++) {
if (!isdigit(i))
textView->DisallowChar(i);
}
textView->SetMaxBytes(4);
const struct alignment_map {
int32 alignment;
const char* name;
} kAlignmentMap[] = {
{B_ALIGN_LEFT, B_TRANSLATE_COMMENT("Left",
"Attribute column alignment in Tracker")},
{B_ALIGN_RIGHT, B_TRANSLATE_COMMENT("Right",
"Attribute column alignment in Tracker")},
{B_ALIGN_CENTER, B_TRANSLATE_COMMENT("Center",
"Attribute column alignment in Tracker")},
{0, NULL}
};
menu = new BPopUpMenu("alignment");
for (int32 i = 0; kAlignmentMap[i].name != NULL; i++) {
BMessage* message = new BMessage(kMsgAlignmentChosen);
message->AddInt32("alignment", kAlignmentMap[i].alignment);
item = new BMenuItem(kAlignmentMap[i].name, message);
menu->AddItem(item);
if (kAlignmentMap[i].alignment == fAttribute.Alignment())
item->SetMarked(true);
}
fAlignmentMenuField = new BMenuField("alignment",
B_TRANSLATE("Alignment:"), menu);
fAlignmentMenuField->SetAlignment(B_ALIGN_RIGHT);
fAcceptButton = new BButton("add",
item ? B_TRANSLATE("Done") : B_TRANSLATE("Add"),
new BMessage(kMsgAccept));
fAcceptButton->SetEnabled(false);
BButton* cancelButton = new BButton("cancel", B_TRANSLATE("Cancel"),
new BMessage(B_QUIT_REQUESTED));
BBox* visibleBox;
BLayoutBuilder::Group<>(this, B_VERTICAL, padding)
.SetInsets(padding, padding, padding, padding)
.AddGrid(padding, padding / 2)
.Add(fPublicNameControl->CreateLabelLayoutItem(), 0, 0)
.Add(fPublicNameControl->CreateTextViewLayoutItem(), 1, 0)
.Add(fAttributeControl->CreateLabelLayoutItem(), 0, 1)
.Add(fAttributeControl->CreateTextViewLayoutItem(), 1, 1)
.Add(typeMenuField->CreateLabelLayoutItem(), 0, 2)
.Add(typeMenuField->CreateMenuBarLayoutItem(), 1, 2)
.End()
.Add(visibleBox = new BBox(B_FANCY_BORDER,
BLayoutBuilder::Grid<>(padding, padding / 2)
.Add(fDisplayAsMenuField->CreateLabelLayoutItem(), 0, 0)
.Add(fDisplayAsMenuField->CreateMenuBarLayoutItem(), 1, 0)
.Add(fEditableCheckBox, 2, 0)
.Add(fSpecialControl->CreateLabelLayoutItem(), 0, 1)
.Add(fSpecialControl->CreateTextViewLayoutItem(), 1, 1, 2)
.Add(fWidthControl->CreateLabelLayoutItem(), 0, 2)
.Add(fWidthControl->CreateTextViewLayoutItem(), 1, 2, 2)
.Add(fAlignmentMenuField->CreateLabelLayoutItem(), 0, 3)
.Add(fAlignmentMenuField->CreateMenuBarLayoutItem(), 1, 3, 2)
.SetInsets(padding, padding, padding, padding)
.View())
)
.AddGroup(B_HORIZONTAL, padding)
.Add(BSpaceLayoutItem::CreateGlue())
.Add(cancelButton)
.Add(fAcceptButton);
visibleBox->SetLabel(fVisibleCheckBox);
fAcceptButton->MakeDefault(true);
fPublicNameControl->MakeFocus(true);
target->PlaceSubWindow(this);
AddToSubset(target);
_CheckDisplayAs();
_CheckAcceptable();
}
void
InspectorWindow::_Init()
{
BScrollView* scrollView;
BMenu* hexMenu = new BMenu("Hex Mode");
BMessage* message = new BMessage(MSG_SET_HEX_MODE);
message->AddInt32("mode", HexModeNone);
BMenuItem* item = new BMenuItem("<None>", message, '0');
hexMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", HexMode8BitInt);
item = new BMenuItem("8-bit integer", message, '1');
hexMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", HexMode16BitInt);
item = new BMenuItem("16-bit integer", message, '2');
hexMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", HexMode32BitInt);
item = new BMenuItem("32-bit integer", message, '3');
hexMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", HexMode64BitInt);
item = new BMenuItem("64-bit integer", message, '4');
hexMenu->AddItem(item);
BMenu* endianMenu = new BMenu("Endian Mode");
message = new BMessage(MSG_SET_ENDIAN_MODE);
message->AddInt32("mode", EndianModeLittleEndian);
item = new BMenuItem("Little Endian", message, 'L');
endianMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", EndianModeBigEndian);
item = new BMenuItem("Big Endian", message, 'B');
endianMenu->AddItem(item);
BMenu* textMenu = new BMenu("Text Mode");
message = new BMessage(MSG_SET_TEXT_MODE);
message->AddInt32("mode", TextModeNone);
item = new BMenuItem("<None>", message, 'N');
textMenu->AddItem(item);
message = new BMessage(*message);
message->ReplaceInt32("mode", TextModeASCII);
item = new BMenuItem("ASCII", message, 'A');
textMenu->AddItem(item);
BLayoutBuilder::Group<>(this, B_VERTICAL)
.SetInsets(4.0f, 4.0f, 4.0f, 4.0f)
.AddGroup(B_HORIZONTAL, 4.0f)
.Add(fAddressInput = new BTextControl("addrInput",
"Target Address:", "",
new BMessage(MSG_INSPECT_ADDRESS)))
.Add(fPreviousBlockButton = new BButton("navPrevious", "<",
new BMessage(MSG_NAVIGATE_PREVIOUS_BLOCK)))
.Add(fNextBlockButton = new BButton("navNext", ">",
new BMessage(MSG_NAVIGATE_NEXT_BLOCK)))
.End()
.AddGroup(B_HORIZONTAL, 4.0f)
.Add(fHexMode = new BMenuField("hexMode", "Hex Mode:",
hexMenu))
.AddGlue()
.Add(fEndianMode = new BMenuField("endianMode", "Endian Mode:",
endianMenu))
.AddGlue()
.Add(fTextMode = new BMenuField("viewMode", "Text Mode:",
textMenu))
.End()
.Add(scrollView = new BScrollView("memory scroll",
NULL, 0, false, true), 3.0f)
.End();
fHexMode->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fEndianMode->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fTextMode->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
int32 targetEndian = fTeam->GetArchitecture()->IsBigEndian()
? EndianModeBigEndian : EndianModeLittleEndian;
scrollView->SetTarget(fMemoryView = MemoryView::Create(fTeam));
fAddressInput->SetTarget(this);
fPreviousBlockButton->SetTarget(this);
fNextBlockButton->SetTarget(this);
fPreviousBlockButton->SetEnabled(false);
fNextBlockButton->SetEnabled(false);
hexMenu->SetLabelFromMarked(true);
hexMenu->SetTargetForItems(fMemoryView);
endianMenu->SetLabelFromMarked(true);
endianMenu->SetTargetForItems(fMemoryView);
textMenu->SetLabelFromMarked(true);
textMenu->SetTargetForItems(fMemoryView);
// default to 8-bit format w/ text display
hexMenu->ItemAt(1)->SetMarked(true);
textMenu->ItemAt(1)->SetMarked(true);
if (targetEndian == EndianModeBigEndian)
endianMenu->ItemAt(1)->SetMarked(true);
else
endianMenu->ItemAt(0)->SetMarked(true);
fAddressInput->TextView()->MakeFocus(true);
}
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 MenuEditor::AttachedToWindow()
{
if (!fInit)
{
BRect rect(Frame());
BRect frame(10, 110, rect.Width() - 10, 130);
fLabelText = new BTextControl(frame, "label", "Label: ", "",
new BMessage(MSG_MENU_SET_ITEM_LABEL));
fLabelText->SetDivider(be_plain_font->StringWidth("Label: "));
fLabelText->SetEnabled(false);
AddChild(fLabelText);
char msg[5];
msg[0] = 0;
strcpy(msg,"none");
/*if (((BControl *)(pointer))->Message() != NULL)
strncpy(msg,(char *)(new int32(((BControl *)(pointer))->Message()->what)),4);*/
frame.Set(10, 130, rect.Width() - 10, 150);
fMsgText = new BTextControl(frame, "msg", "Message: ", msg,
new BMessage(MSG_MENU_SET_ITEM_MSG));
fMsgText->TextView()->SetMaxBytes(4);
fMsgText->SetDivider(be_plain_font->StringWidth("Message: "));
fMsgText->SetEnabled(false);
AddChild(fMsgText);
frame.Set(10, 150, be_plain_font->StringWidth("Shortcut: ") + 40, 170);
fShortcutText = new BTextControl(frame, "shrtct", "Shortcut: ", "",
new BMessage(MSG_MENU_SET_ITEM_SHORTCUT));
fShortcutText->SetDivider(be_plain_font->StringWidth("Shortcut: "));
fShortcutText->SetEnabled(false);
fShortcutText->TextView()->SetMaxBytes(1);
AddChild(fShortcutText);
BMenu *meniu = new BMenu("Modifier Keys");
meniu->AddItem(new BMenuItem("Option", new BMessage(MSG_MENU_SET_ITEM_MARKED)));
meniu->AddItem(new BMenuItem("Shift", new BMessage(MSG_MENU_SET_ITEM_MARKED)));
meniu->AddItem(new BMenuItem("Control", new BMessage(MSG_MENU_SET_ITEM_MARKED)));
frame.Set(be_plain_font->StringWidth("Shortcut: ") + 50, 150,
rect.Width() - 10, 170);
fModifierField = new BMenuField(frame, "modchoice", NULL, meniu);
fModifierField->SetEnabled(false);
meniu->SetRadioMode(false);
meniu->SetLabelFromMarked(false);
AddChild(fModifierField);
frame.Set(10, 175, rect.Width() - 10, 195);
fEnabledBox = new BCheckBox(frame, "enabled", "Enabled",
new BMessage(MSG_MENU_SET_ITEM_ENABLED));
fEnabledBox->SetEnabled(false);
AddChild(fEnabledBox);
frame.Set(10, 200, (rect.Width() / 2) - 10, 220);
fAddItemBtn = new BButton(frame, "addiantem", "Add Item",
new BMessage(MSG_MENU_NEW_ITEM));
AddChild(fAddItemBtn);
frame.Set((rect.Width() / 2) + 10, 200, rect.Width() - 10, 220);
fAddSeparatorBtn = new BButton(frame, "addsepitem", "Add Separator",
new BMessage(MSG_MENU_ADD_SEPARATOR));
AddChild(fAddSeparatorBtn);
}
fListView->SetTarget(this);
fLabelText->SetTarget(this);
fMsgText->SetTarget(this);
fShortcutText->SetTarget(this);
fModifierField->Menu()->SetTargetForItems(this);
fEnabledBox->SetTarget(this);
fAddItemBtn->SetTarget(this);
fAddSeparatorBtn->SetTarget(this);
}
InterfaceWindow::InterfaceWindow( intf_thread_t * _p_intf, BRect frame,
const char * name )
: BWindow( frame, name, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_NOT_ZOOMABLE | B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
/* Initializations */
p_intf( _p_intf ),
p_input( NULL ),
p_playlist( NULL ),
fFilePanel( NULL ),
fLastUpdateTime( system_time() ),
fSettings( new BMessage( 'sett' ) )
{
p_playlist = pl_Hold( p_intf );
var_AddCallback( p_playlist, "intf-change", PlaylistChanged, this );
var_AddCallback( p_playlist, "item-change", PlaylistChanged, this );
var_AddCallback( p_playlist, "playlist-item-append", PlaylistChanged, this );
var_AddCallback( p_playlist, "playlist-item-deleted", PlaylistChanged, this );
var_AddCallback( p_playlist, "item-current", PlaylistChanged, this );
char psz_tmp[1024];
#define ADD_ELLIPSIS( a ) \
memset( psz_tmp, 0, 1024 ); \
snprintf( psz_tmp, 1024, "%s%s", a, B_UTF8_ELLIPSIS );
BScreen screen;
BRect screen_rect = screen.Frame();
BRect window_rect;
window_rect.Set( ( screen_rect.right - PREFS_WINDOW_WIDTH ) / 2,
( screen_rect.bottom - PREFS_WINDOW_HEIGHT ) / 2,
( screen_rect.right + PREFS_WINDOW_WIDTH ) / 2,
( screen_rect.bottom + PREFS_WINDOW_HEIGHT ) / 2 );
fPreferencesWindow = new PreferencesWindow( p_intf, window_rect, _("Preferences") );
window_rect.Set( screen_rect.right - 500,
screen_rect.top + 50,
screen_rect.right - 150,
screen_rect.top + 250 );
#if 0
fPlaylistWindow = new PlayListWindow( window_rect, _("Playlist"), this, p_intf );
window_rect.Set( screen_rect.right - 550,
screen_rect.top + 300,
screen_rect.right - 150,
screen_rect.top + 500 );
#endif
fMessagesWindow = new MessagesWindow( p_intf, window_rect, _("Messages") );
// the media control view
p_mediaControl = new MediaControlView( p_intf, BRect( 0.0, 0.0, 250.0, 50.0 ) );
p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
float width, height;
p_mediaControl->GetPreferredSize( &width, &height );
// set up the main menu
fMenuBar = new BMenuBar( BRect(0.0, 0.0, width, 15.0), "main menu",
B_FOLLOW_NONE, B_ITEMS_IN_ROW, false );
// make menu bar resize to correct height
float menuWidth, menuHeight;
fMenuBar->GetPreferredSize( &menuWidth, &menuHeight );
fMenuBar->ResizeTo( width, menuHeight ); // don't change! it's a workarround!
// take care of proper size for ourself
height += fMenuBar->Bounds().Height();
ResizeTo( width, height );
p_mediaControl->MoveTo( fMenuBar->Bounds().LeftBottom() + BPoint(0.0, 1.0) );
AddChild( fMenuBar );
// Add the file Menu
BMenu* fileMenu = new BMenu( _("File") );
fMenuBar->AddItem( fileMenu );
ADD_ELLIPSIS( _("Open File") );
fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O') );
fileMenu->AddItem( new CDMenu( _("Open Disc") ) );
ADD_ELLIPSIS( _("Open Subtitles") );
fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( LOAD_SUBFILE ) ) );
fileMenu->AddSeparatorItem();
ADD_ELLIPSIS( _("About") );
BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( B_ABOUT_REQUESTED ), 'A');
item->SetTarget( be_app );
fileMenu->AddItem( item );
fileMenu->AddItem( new BMenuItem( _("Quit"), new BMessage( B_QUIT_REQUESTED ), 'Q') );
fLanguageMenu = new LanguageMenu( p_intf, _("Language"), "audio-es" );
fSubtitlesMenu = new LanguageMenu( p_intf, _("Subtitles"), "spu-es" );
/* Add the Audio menu */
fAudioMenu = new BMenu( _("Audio") );
fMenuBar->AddItem ( fAudioMenu );
fAudioMenu->AddItem( fLanguageMenu );
fAudioMenu->AddItem( fSubtitlesMenu );
fPrevTitleMI = new BMenuItem( _("Prev Title"), new BMessage( PREV_TITLE ) );
fNextTitleMI = new BMenuItem( _("Next Title"), new BMessage( NEXT_TITLE ) );
fPrevChapterMI = new BMenuItem( _("Previous chapter"), new BMessage( PREV_CHAPTER ) );
fNextChapterMI = new BMenuItem( _("Next chapter"), new BMessage( NEXT_CHAPTER ) );
/* Add the Navigation menu */
fNavigationMenu = new BMenu( _("Navigation") );
fMenuBar->AddItem( fNavigationMenu );
fNavigationMenu->AddItem( fPrevTitleMI );
fNavigationMenu->AddItem( fNextTitleMI );
fNavigationMenu->AddItem( fTitleMenu = new TitleMenu( _("Go to Title"), p_intf ) );
fNavigationMenu->AddSeparatorItem();
fNavigationMenu->AddItem( fPrevChapterMI );
fNavigationMenu->AddItem( fNextChapterMI );
fNavigationMenu->AddItem( fChapterMenu = new ChapterMenu( _("Go to Chapter"), p_intf ) );
/* Add the Speed menu */
fSpeedMenu = new BMenu( _("Speed") );
fSpeedMenu->SetRadioMode( true );
fSpeedMenu->AddItem(
fHeighthMI = new BMenuItem( "1/8x", new BMessage( HEIGHTH_PLAY ) ) );
fSpeedMenu->AddItem(
fQuarterMI = new BMenuItem( "1/4x", new BMessage( QUARTER_PLAY ) ) );
fSpeedMenu->AddItem(
fHalfMI = new BMenuItem( "1/2x", new BMessage( HALF_PLAY ) ) );
fSpeedMenu->AddItem(
fNormalMI = new BMenuItem( "1x", new BMessage( NORMAL_PLAY ) ) );
fSpeedMenu->AddItem(
fTwiceMI = new BMenuItem( "2x", new BMessage( TWICE_PLAY ) ) );
fSpeedMenu->AddItem(
fFourMI = new BMenuItem( "4x", new BMessage( FOUR_PLAY ) ) );
fSpeedMenu->AddItem(
fHeightMI = new BMenuItem( "8x", new BMessage( HEIGHT_PLAY ) ) );
fMenuBar->AddItem( fSpeedMenu );
/* Add the Show menu */
fShowMenu = new BMenu( _("Window") );
#if 0
ADD_ELLIPSIS( _("Playlist") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PLAYLIST ), 'P') );
#endif
ADD_ELLIPSIS( _("Messages") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_MESSAGES ), 'M' ) );
ADD_ELLIPSIS( _("Preferences") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PREFERENCES ), 'S' ) );
fMenuBar->AddItem( fShowMenu );
// add the media control view after the menubar is complete
// because it will set the window size limits in AttachedToWindow()
// and the menubar needs to report the correct PreferredSize()
AddChild( p_mediaControl );
/* Prepare fow showing */
_SetMenusEnabled( false );
p_mediaControl->SetEnabled( false );
_RestoreSettings();
Show();
}
