int
main(int argc, char** argv)
{
BApplication app("application/x-vnd.haiku-look");
BWindow* window = new Window(BRect(50, 50, 100, 100),
"Look at these pretty controls!", B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS
| B_QUIT_ON_WINDOW_CLOSE);
window->SetLayout(new BGroupLayout(B_HORIZONTAL));
// create some controls
// BListView
BListView* listView = new BListView();
for (int32 i = 0; i < 20; i++) {
BString itemLabel("List item ");
itemLabel << i + 1;
listView->AddItem(new BStringItem(itemLabel.String()));
}
BScrollView* scrollView = new BScrollView("scroller", listView, 0,
true, true);
scrollView->SetExplicitMinSize(BSize(300, 140));
// BColumnListView
BColumnListView* columnListView = new BColumnListView("clv", 0,
B_FANCY_BORDER);
// B_PLAIN_BORDER);
// B_NO_BORDER);
columnListView->AddColumn(new BTitledColumn("Short",
150, 50, 500, B_ALIGN_LEFT), 0);
columnListView->AddColumn(new BTitledColumn("Medium Length",
100, 50, 500, B_ALIGN_CENTER), 1);
columnListView->AddColumn(new BTitledColumn("Some Long Column Name",
130, 50, 500, B_ALIGN_RIGHT), 2);
// for (int32 i = 0; i < 20; i++) {
// BString itemLabel("List Item ");
// itemLabel << i + 1;
// columnListView->AddItem(new BStringItem(itemLabel.String()));
// }
BGridView* controls = new BGridView(kInset, kInset);
BGridLayout* layout = controls->GridLayout();
controls->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
int32 row = 0;
add_controls<BButton>(layout, row);
add_controls<BCheckBox>(layout, row);
add_controls<BRadioButton>(layout, row);
add_menu_fields(layout, row);
add_text_controls(layout, row);
add_sliders(layout, row);
add_status_bars(layout, row);
BColorControl* colorControl = new BColorControl(B_ORIGIN, B_CELLS_32x8,
8.0f, "color control");
layout->AddView(colorControl, 0, row, 4);
BTabView* tabView = new BTabView("tab view", B_WIDTH_FROM_WIDEST);
BGroupView* content = new BGroupView(B_VERTICAL, kInset);
BLayoutBuilder::Group<>(content)
.Add(scrollView)
.Add(columnListView)
.Add(controls)
.SetInsets(kInset, kInset, kInset, kInset);
content->SetName("Tab 1");
tabView->AddTab(content);
BView* tab2 = new BView("Tab 2", 0);
tab2->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
tabView->AddTab(tab2);
tabView->AddTab(new BView("Tab 3", 0));
BMenuBar* menuBar = new BMenuBar("menu bar");
BMenu* menu = new BMenu("File");
menu->AddItem(new BMenuItem("Test Open BFilePanel",
new BMessage(MSG_TEST_OPEN_FILE_PANEL)));
menu->AddItem(new BMenuItem("Test Save BFilePanel",
new BMessage(MSG_TEST_SAVE_FILE_PANEL)));
menu->AddItem(new BMenuItem("Click me!", NULL));
menu->AddItem(new BMenuItem("Another option", NULL));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED)));
menuBar->AddItem(menu);
menu = new BMenu("Edit");
menu->SetEnabled(false);
menu->AddItem(new BMenuItem("Cut", NULL));
menu->AddItem(new BMenuItem("Copy", NULL));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Past", NULL));
menuBar->AddItem(menu);
menu = new BMenu("One Item");
menu->AddItem(new BMenuItem("Only", NULL));
menuBar->AddItem(menu);
menu = new BMenu("Sub Menu");
BMenu* subMenu = new BMenu("Click me");
subMenu->AddItem(new BMenuItem("Either", NULL));
subMenu->AddItem(new BMenuItem("Or", NULL));
subMenu->SetRadioMode(true);
menu->AddItem(subMenu);
menuBar->AddItem(menu);
BButton* okButton = new BButton("OK", new BMessage(B_QUIT_REQUESTED));
BLayoutBuilder::Group<>(window, B_VERTICAL, 0)
.Add(menuBar)
.AddGroup(B_VERTICAL, kInset)
.SetInsets(kInset, kInset, kInset, kInset)
.Add(tabView)
.AddGroup(B_HORIZONTAL, kInset)
.Add(new BButton("Revert", new BMessage(MSG_TOGGLE_LOOK)))
.AddGlue()
.Add(new BButton("Cancel", NULL))
.Add(okButton);
window->SetDefaultButton(okButton);
window->Show();
app.Run();
return 0;
}
InstallerWindow::InstallerWindow()
: BWindow(BRect(-2000, -2000, -1800, -1800), TR("Installer"),
B_TITLED_WINDOW, B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS),
fEncouragedToSetupPartitions(false),
fDriveSetupLaunched(false),
fInstallStatus(kReadyForInstall),
fWorkerThread(new WorkerThread(this)),
fCopyEngineCancelSemaphore(-1)
{
LogoView* logoView = new LogoView();
fStatusView = new BTextView("statusView", be_plain_font, NULL, B_WILL_DRAW);
fStatusView->SetInsets(10, 10, 10, 10);
fStatusView->MakeEditable(false);
fStatusView->MakeSelectable(false);
BSize logoSize = logoView->MinSize();
logoView->SetExplicitMaxSize(logoSize);
fStatusView->SetExplicitMinSize(BSize(logoSize.width * 0.66, B_SIZE_UNSET));
fDestMenu = new BPopUpMenu(TR("scanning" B_UTF8_ELLIPSIS), true, false);
fSrcMenu = new BPopUpMenu(TR("scanning" B_UTF8_ELLIPSIS), true, false);
fSrcMenuField = new BMenuField("srcMenuField", TR("Install from:"),
fSrcMenu, NULL);
fSrcMenuField->SetAlignment(B_ALIGN_RIGHT);
fDestMenuField = new BMenuField("destMenuField", TR("Onto:"), fDestMenu,
NULL);
fDestMenuField->SetAlignment(B_ALIGN_RIGHT);
fPackagesSwitch = new PaneSwitch("options_button");
fPackagesSwitch->SetLabels(TR("Hide optional packages"),
TR("Show optional packages"));
fPackagesSwitch->SetMessage(new BMessage(SHOW_BOTTOM_MESSAGE));
fPackagesSwitch->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED,
B_SIZE_UNSET));
fPackagesSwitch->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_TOP));
fPackagesView = new PackagesView("packages_view");
BScrollView* packagesScrollView = new BScrollView("packagesScroll",
fPackagesView, B_WILL_DRAW, false, true);
const char* requiredDiskSpaceString
= TR("Additional disk space required: 0.0 KB");
fSizeView = new BStringView("size_view", requiredDiskSpaceString);
fSizeView->SetAlignment(B_ALIGN_RIGHT);
fSizeView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
fSizeView->SetExplicitAlignment(
BAlignment(B_ALIGN_RIGHT, B_ALIGN_MIDDLE));
fProgressBar = new BStatusBar("progress", TR("Install progress: "));
fProgressBar->SetMaxValue(100.0);
fBeginButton = new BButton("begin_button", TR("Begin"),
new BMessage(BEGIN_MESSAGE));
fBeginButton->MakeDefault(true);
fBeginButton->SetEnabled(false);
fSetupButton = new BButton("setup_button",
TR("Set up partitions" B_UTF8_ELLIPSIS), new BMessage(SETUP_MESSAGE));
fMakeBootableButton = new BButton("makebootable_button",
TR("Write boot sector"), new BMessage(MSG_WRITE_BOOT_SECTOR));
fMakeBootableButton->SetEnabled(false);
SetLayout(new BGroupLayout(B_HORIZONTAL));
AddChild(BGroupLayoutBuilder(B_VERTICAL)
.Add(BGroupLayoutBuilder(B_HORIZONTAL)
.Add(logoView)
.Add(fStatusView)
)
.Add(new BSeparatorView(B_HORIZONTAL, B_PLAIN_BORDER))
.Add(BGroupLayoutBuilder(B_VERTICAL, 10)
.Add(BGridLayoutBuilder(0, 10)
.Add(fSrcMenuField->CreateLabelLayoutItem(), 0, 0)
.Add(fSrcMenuField->CreateMenuBarLayoutItem(), 1, 0)
.Add(fDestMenuField->CreateLabelLayoutItem(), 0, 1)
.Add(fDestMenuField->CreateMenuBarLayoutItem(), 1, 1)
.Add(BSpaceLayoutItem::CreateVerticalStrut(5), 0, 2, 2)
.Add(fPackagesSwitch, 0, 3, 2)
.Add(packagesScrollView, 0, 4, 2)
.Add(fProgressBar, 0, 5, 2)
.Add(fSizeView, 0, 6, 2)
)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 10)
.Add(fSetupButton)
.Add(fMakeBootableButton)
.AddGlue()
.Add(fBeginButton)
)
.SetInsets(10, 10, 10, 10)
)
);
// Make the optional packages and progress bar invisible on start
fPackagesLayoutItem = layout_item_for(packagesScrollView);
fPkgSwitchLayoutItem = layout_item_for(fPackagesSwitch);
fSizeViewLayoutItem = layout_item_for(fSizeView);
fProgressLayoutItem = layout_item_for(fProgressBar);
fPackagesLayoutItem->SetVisible(false);
fSizeViewLayoutItem->SetVisible(false);
fProgressLayoutItem->SetVisible(false);
// Setup tool tips for the non-obvious features
fSetupButton->SetToolTip(
TR("Launch the DriveSetup utility to partition\n"
"available hard drives and other media.\n"
"Partitions can be initialized with the\n"
"Be File System needed for a Antares boot\n"
"partition."));
fMakeBootableButton->SetToolTip(
TR("Writes the Antares boot code to the partition start\n"
"sector. This step is automatically performed by\n"
"the installation, but you can manually make a\n"
"partition bootable in case you do not need to\n"
"perform an installation."));
// finish creating window
if (!be_roster->IsRunning(kDeskbarSignature))
SetFlags(Flags() | B_NOT_MINIMIZABLE);
CenterOnScreen();
Show();
fDriveSetupLaunched = be_roster->IsRunning(DRIVESETUP_SIG);
if (Lock()) {
fSetupButton->SetEnabled(!fDriveSetupLaunched);
Unlock();
}
be_roster->StartWatching(this);
PostMessage(START_SCAN);
}
virtual BSize MaxSize()
{
return BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
}
AboutView::AboutView()
: BView("aboutview", B_WILL_DRAW | B_PULSE_NEEDED),
fLastActionTime(system_time()),
fScrollRunner(NULL)
{
// Begin Construction of System Information controls
system_info systemInfo;
get_system_info(&systemInfo);
// Create all the various labels for system infomation
// OS Version
char string[1024];
strlcpy(string, B_TRANSLATE("Unknown"), sizeof(string));
// the version is stored in the BEOS:APP_VERSION attribute of libbe.so
BPath path;
if (find_directory(B_BEOS_LIB_DIRECTORY, &path) == B_OK) {
path.Append("libbe.so");
BAppFileInfo appFileInfo;
version_info versionInfo;
BFile file;
if (file.SetTo(path.Path(), B_READ_ONLY) == B_OK
&& appFileInfo.SetTo(&file) == B_OK
&& appFileInfo.GetVersionInfo(&versionInfo,
B_APP_VERSION_KIND) == B_OK
&& versionInfo.short_info[0] != '\0')
strlcpy(string, versionInfo.short_info, sizeof(string));
}
// Add system revision
const char* haikuRevision = __get_haiku_revision();
if (haikuRevision != NULL) {
strlcat(string, " (", sizeof(string));
strlcat(string, B_TRANSLATE("Revision"), sizeof(string));
strlcat(string, " ", sizeof(string));
strlcat(string, haikuRevision, sizeof(string));
strlcat(string, ")", sizeof(string));
}
BStringView* versionView = new BStringView("ostext", string);
versionView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
// GCC version
BEntry gccFourHybrid("/boot/system/lib/gcc2/libstdc++.r4.so");
BEntry gccTwoHybrid("/boot/system/lib/gcc4/libsupc++.so");
bool isHybrid = gccFourHybrid.Exists() || gccTwoHybrid.Exists();
if (isHybrid) {
snprintf(string, sizeof(string), B_TRANSLATE("GCC %d Hybrid"),
__GNUC__);
} else
snprintf(string, sizeof(string), "GCC %d", __GNUC__);
BStringView* gccView = new BStringView("gcctext", string);
gccView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
#if __GNUC__ == 2
if (isHybrid) {
// do now show the GCC version if it's the default
gccView->Hide();
}
#endif
// CPU count, type and clock speed
char processorLabel[256];
if (systemInfo.cpu_count > 1) {
snprintf(processorLabel, sizeof(processorLabel),
B_TRANSLATE("%ld Processors:"), systemInfo.cpu_count);
} else
strlcpy(processorLabel, B_TRANSLATE("Processor:"),
sizeof(processorLabel));
BString cpuType;
cpuType << get_cpu_vendor_string(systemInfo.cpu_type)
<< " " << get_cpu_model_string(&systemInfo);
BStringView* cpuView = new BStringView("cputext", cpuType.String());
cpuView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
int32 clockSpeed = get_rounded_cpu_speed();
if (clockSpeed < 1000)
snprintf(string, sizeof(string), B_TRANSLATE("%ld MHz"), clockSpeed);
else
snprintf(string, sizeof(string), B_TRANSLATE("%.2f GHz"),
clockSpeed / 1000.0f);
BStringView* frequencyView = new BStringView("frequencytext", string);
frequencyView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
// RAM
BStringView *memSizeView = new BStringView("ramsizetext",
MemSizeToString(string, sizeof(string), &systemInfo));
memSizeView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
fMemView = new BStringView("ramtext",
MemUsageToString(string, sizeof(string), &systemInfo));
fMemView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
// Kernel build time/date
snprintf(string, sizeof(string), "%s %s",
systemInfo.kernel_build_date, systemInfo.kernel_build_time);
BStringView* kernelView = new BStringView("kerneltext", string);
kernelView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
// Uptime
fUptimeView = new BTextView("uptimetext");
fUptimeView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fUptimeView->MakeEditable(false);
fUptimeView->MakeSelectable(false);
fUptimeView->SetWordWrap(true);
fUptimeView->SetText(UptimeToString(string, sizeof(string)));
const float offset = 5;
SetLayout(new BGroupLayout(B_HORIZONTAL, 0));
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
BLayoutBuilder::Group<>((BGroupLayout*)GetLayout())
.AddGroup(B_VERTICAL, 0)
.Add(new LogoView())
.AddGroup(B_VERTICAL, 0)
.Add(_CreateLabel("oslabel", B_TRANSLATE("Version:")))
.Add(versionView)
.Add(gccView)
.AddStrut(offset)
.Add(_CreateLabel("cpulabel", processorLabel))
.Add(cpuView)
.Add(frequencyView)
.AddStrut(offset)
.Add(_CreateLabel("memlabel", B_TRANSLATE("Memory:")))
.Add(memSizeView)
.Add(fMemView)
.AddStrut(offset)
.Add(_CreateLabel("kernellabel", B_TRANSLATE("Kernel:")))
.Add(kernelView)
.AddStrut(offset)
.Add(_CreateLabel("uptimelabel",
B_TRANSLATE("Time running:")))
.Add(fUptimeView)
.SetInsets(5, 5, 5, 5)
.End()
// TODO: investigate: adding this causes the time to be cut
//.AddGlue()
.End()
.Add(_CreateCreditsView());
float min = fMemView->MinSize().width * 1.1f;
fCreditsView->SetExplicitMinSize(BSize(min, min));
}
void
AppView::InitView()
{
PRINT(("AppView::InitView()\n"));
m_preferences = new Preferences();
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
m_pick_list_view = new PickListView("m_pick_list_view");
AddOnView * aView;
// Edit view
aView = new EditorView(m_preferences);
if (aView->InitCheck() == B_OK)
m_pick_list_view->AddView(aView);
else
delete aView;
// Copy view
aView = new TAView(m_preferences);
if (aView->InitCheck() == B_OK)
m_pick_list_view->AddView(aView);
else
delete aView;
// Name view
aView = new NAView(m_preferences);
if (aView->InitCheck() == B_OK)
m_pick_list_view->AddView(aView);
else
delete aView;
// MPEG view
aView = new MPEGView(m_preferences);
if (aView->InitCheck() == B_OK)
m_pick_list_view->AddView(aView);
else
delete aView;
#ifdef _TTE_
aView = new TTInfoView(m_preferences);
if (aView->InitCheck() == B_OK)
m_pick_list_view->AddView(aView);
else
delete aView;
#endif
m_list_view = new AKListView("m_list_view",B_MULTIPLE_SELECTION_LIST);
m_list_view->SetSelectionMessage(new BMessage(SELECTION_CHANGED));
m_scroll_view = new BScrollView("m_scroll_view",m_list_view, 0, true, true);
m_scroll_view->SetExplicitMinSize(BSize(300, 0));
m_selected_string_view = new BStringView("m_selected_string_view","");
m_selected_string_view->SetAlignment(B_ALIGN_RIGHT);
m_selected_string_view->SetFontSize(10);
m_apply_button = new BButton("m_apply_button", APPLY_BUTTON,
new BMessage(MSG_APPLY));
m_apply_button->SetEnabled(false);
m_reset_button = new BButton("m_reset_button", RESET_BUTTON,
new BMessage(MSG_RESET));
m_reset_button->SetEnabled(true);
m_status_bar = new BStatusBar("m_status_bar","0%","100%");
m_status_bar->Hide();
m_barberpole = new Barberpole("barberpole", B_WILL_DRAW|B_FRAME_EVENTS);
m_status_card = new BCardLayout();
BLayoutBuilder::Group<>(this, B_VERTICAL)
.SetInsets(B_USE_WINDOW_INSETS, 0, B_USE_WINDOW_INSETS,
B_USE_WINDOW_INSETS)
.AddGroup(B_HORIZONTAL)
.Add(m_pick_list_view)
.Add(m_scroll_view)
.End()
.AddGroup(B_HORIZONTAL)
.AddGlue()
.Add(m_selected_string_view)
.End()
.AddGroup(B_HORIZONTAL)
.Add(m_status_card)
.Add(m_reset_button)
.Add(m_apply_button);
m_status_card->AddView(m_barberpole);
m_status_card->AddView(m_status_bar);
m_status_card->SetVisibleItem((int32)0);
/*
BView *dragger = FindView("_dragger_");
if (dragger) {
RemoveChild(dragger); // tricky: avoid redraw bugs
AddChild(dragger);
dragger->SetViewColor(ViewColor());
dragger->SetLowColor(LowColor());
}
*/
// The following is a kludge to give each addon view a
// pointer to the list view. It's done this way, for now,
// as the m_list_view is created after the add-ons
// due to how the layout is done.
AddOnView* addOnView;
int numViews = m_pick_list_view->CountViews();
for (int i = 0; i < numViews; i++) {
addOnView = dynamic_cast<AddOnView*>(m_pick_list_view->ViewAt(i));
addOnView->SetListView(m_list_view);
}
SelectView(m_preferences->GetMode());
}
TeamMonitorWindow::TeamMonitorWindow()
:
BWindow(BRect(0, 0, 350, 400), B_TRANSLATE("Team monitor"),
B_TITLED_WINDOW_LOOK, B_MODAL_ALL_WINDOW_FEEL,
B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS
| B_CLOSE_ON_ESCAPE | B_AUTO_UPDATE_SIZE_LIMITS,
B_ALL_WORKSPACES),
fQuitting(false),
fUpdateRunner(NULL)
{
BGroupLayout* layout = new BGroupLayout(B_VERTICAL);
float inset = 10;
layout->SetInsets(inset, inset, inset, inset);
layout->SetSpacing(inset);
SetLayout(layout);
layout->View()->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fListView = new BListView("teams");
fListView->SetSelectionMessage(new BMessage(TM_SELECTED_TEAM));
BScrollView* scrollView = new BScrollView("scroll_teams", fListView,
0, B_SUPPORTS_LAYOUT, false, true, B_FANCY_BORDER);
layout->AddView(scrollView);
BGroupView* groupView = new BGroupView(B_HORIZONTAL);
layout->AddView(groupView);
fKillButton = new BButton("kill", B_TRANSLATE("Kill application"),
new BMessage(TM_KILL_APPLICATION));
groupView->AddChild(fKillButton);
fKillButton->SetEnabled(false);
fQuitButton = new BButton("quit", B_TRANSLATE("Quit application"),
new BMessage(TM_QUIT_APPLICATION));
groupView->AddChild(fQuitButton);
fQuitButton->SetEnabled(false);
groupView->GroupLayout()->AddItem(BSpaceLayoutItem::CreateGlue());
fDescriptionView = new TeamDescriptionView;
layout->AddView(fDescriptionView);
groupView = new BGroupView(B_HORIZONTAL);
layout->AddView(groupView);
BButton* forceReboot = new BButton("force", B_TRANSLATE("Force reboot"),
new BMessage(TM_FORCE_REBOOT));
groupView->GroupLayout()->AddView(forceReboot);
BSpaceLayoutItem* glue = BSpaceLayoutItem::CreateGlue();
glue->SetExplicitMinSize(BSize(inset, -1));
groupView->GroupLayout()->AddItem(glue);
fRestartButton = new BButton("restart", B_TRANSLATE("Restart the desktop"),
new BMessage(TM_RESTART_DESKTOP));
SetDefaultButton(fRestartButton);
groupView->GroupLayout()->AddView(fRestartButton);
glue = BSpaceLayoutItem::CreateGlue();
glue->SetExplicitMinSize(BSize(inset, -1));
groupView->GroupLayout()->AddItem(glue);
fCancelButton = new BButton("cancel", B_TRANSLATE("Cancel"),
new BMessage(TM_CANCEL));
SetDefaultButton(fCancelButton);
groupView->GroupLayout()->AddView(fCancelButton);
BSize preferredSize = layout->View()->PreferredSize();
if (preferredSize.width > Bounds().Width())
ResizeTo(preferredSize.width, Bounds().Height());
if (preferredSize.height > Bounds().Height())
ResizeTo(Bounds().Width(), preferredSize.height);
BRect screenFrame = BScreen(this).Frame();
BPoint point;
point.x = (screenFrame.Width() - Bounds().Width()) / 2;
point.y = (screenFrame.Height() - Bounds().Height()) / 2;
if (screenFrame.Contains(point))
MoveTo(point);
SetSizeLimits(Bounds().Width(), Bounds().Width() * 2,
Bounds().Height(), screenFrame.Height());
fRestartButton->Hide();
AddShortcut('T', B_COMMAND_KEY | B_OPTION_KEY,
new BMessage(kMsgLaunchTerminal));
AddShortcut('W', B_COMMAND_KEY, new BMessage(B_QUIT_REQUESTED));
gLocalizedNamePreferred
= BLocaleRoster::Default()->IsFilesystemTranslationPreferred();
gTeamMonitorWindow = this;
this->AddCommonFilter(new BMessageFilter(B_ANY_DELIVERY,
B_ANY_SOURCE, B_KEY_DOWN, FilterKeyDown));
if (be_app->Lock()) {
be_app->AddCommonFilter(new BMessageFilter(B_ANY_DELIVERY,
B_ANY_SOURCE, B_LOCALE_CHANGED, FilterLocaleChanged));
be_app->Unlock();
}
}
DescriptionTextView(const char* name, float minHeight)
:
BTextView(name)
{
SetExplicitMinSize(BSize(B_SIZE_UNSET, minHeight));
}
ModifierKeysWindow::ModifierKeysWindow()
:
BWindow(BRect(0, 0, 360, 220), B_TRANSLATE("Modifier keys"),
B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE
| B_AUTO_UPDATE_SIZE_LIMITS)
{
get_key_map(&fCurrentMap, &fCurrentBuffer);
get_key_map(&fSavedMap, &fSavedBuffer);
BStringView* keyRole = new BStringView("key role",
B_TRANSLATE_COMMENT("Role", "As in the role of a modifier key"));
keyRole->SetAlignment(B_ALIGN_RIGHT);
keyRole->SetFont(be_bold_font);
BStringView* keyLabel = new BStringView("key label",
B_TRANSLATE_COMMENT("Key", "As in a computer keyboard key"));
keyLabel->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
keyLabel->SetFont(be_bold_font);
BMenuField* shiftMenuField = _CreateShiftMenuField();
shiftMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* controlMenuField = _CreateControlMenuField();
controlMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* optionMenuField = _CreateOptionMenuField();
optionMenuField->SetAlignment(B_ALIGN_RIGHT);
BMenuField* commandMenuField = _CreateCommandMenuField();
commandMenuField->SetAlignment(B_ALIGN_RIGHT);
fShiftConflictView = new ConflictView("shift warning view");
fShiftConflictView->SetExplicitMaxSize(BSize(15, 15));
fControlConflictView = new ConflictView("control warning view");
fControlConflictView->SetExplicitMaxSize(BSize(15, 15));
fOptionConflictView = new ConflictView("option warning view");
fOptionConflictView->SetExplicitMaxSize(BSize(15, 15));
fCommandConflictView = new ConflictView("command warning view");
fCommandConflictView->SetExplicitMaxSize(BSize(15, 15));
fCancelButton = new BButton("cancelButton", B_TRANSLATE("Cancel"),
new BMessage(B_QUIT_REQUESTED));
fRevertButton = new BButton("revertButton", B_TRANSLATE("Revert"),
new BMessage(kMsgRevertModifiers));
fRevertButton->SetEnabled(false);
fOkButton = new BButton("okButton", B_TRANSLATE("Set modifier keys"),
new BMessage(kMsgApplyModifiers));
fOkButton->MakeDefault(true);
// Build the layout
SetLayout(new BGroupLayout(B_VERTICAL));
AddChild(BLayoutBuilder::Group<>(B_VERTICAL)
.AddGrid(B_USE_DEFAULT_SPACING, B_USE_SMALL_SPACING)
.Add(keyRole, 0, 0)
.Add(keyLabel, 1, 0, 2, 1)
.Add(shiftMenuField->CreateLabelLayoutItem(), 0, 1)
.Add(shiftMenuField->CreateMenuBarLayoutItem(), 1, 1)
.Add(fShiftConflictView, 2, 1)
.Add(controlMenuField->CreateLabelLayoutItem(), 0, 2)
.Add(controlMenuField->CreateMenuBarLayoutItem(), 1, 2)
.Add(fControlConflictView, 2, 2)
.Add(optionMenuField->CreateLabelLayoutItem(), 0, 3)
.Add(optionMenuField->CreateMenuBarLayoutItem(), 1, 3)
.Add(fOptionConflictView, 2, 3)
.Add(commandMenuField->CreateLabelLayoutItem(), 0, 4)
.Add(commandMenuField->CreateMenuBarLayoutItem(), 1, 4)
.Add(fCommandConflictView, 2, 4)
.End()
.AddGlue()
.AddGroup(B_HORIZONTAL)
.Add(fCancelButton)
.AddGlue()
.Add(fRevertButton)
.Add(fOkButton)
.End()
.SetInsets(B_USE_DEFAULT_SPACING)
);
_MarkMenuItems();
_ValidateDuplicateKeys();
CenterOnScreen();
}
// ---------------------------------------------------------------
// Constructor
//
// Sets up the view settings
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
SGIView::SGIView(const char* name, uint32 flags, TranslatorSettings* settings)
:
BView(name, flags, new BGroupLayout(B_VERTICAL)),
fSettings(settings)
{
BPopUpMenu* menu = new BPopUpMenu("pick compression");
uint32 currentCompression =
fSettings->SetGetInt32(SGI_SETTING_COMPRESSION);
// create the menu items with the various compression methods
add_menu_item(menu, SGI_COMP_NONE, B_TRANSLATE("None"),
currentCompression);
// menu->AddSeparatorItem();
add_menu_item(menu, SGI_COMP_RLE, B_TRANSLATE("RLE"), currentCompression);
// DON'T turn this on, it's so slow that I didn't wait long enough
// the one time I tested this. So I don't know if the code even works.
// Supposedly, this would look for an already written scanline, and
// modify the scanline tables so that the current row is not written
// at all...
// add_menu_item(menu, SGI_COMP_ARLE, "Agressive RLE", currentCompression);
fCompressionMF = new BMenuField("compression",
B_TRANSLATE("Use compression:"), menu);
BAlignment labelAlignment(B_ALIGN_LEFT, B_ALIGN_NO_VERTICAL);
BStringView* titleView = new BStringView("title",
B_TRANSLATE("SGI image translator"));
titleView->SetFont(be_bold_font);
titleView->SetExplicitAlignment(labelAlignment);
char detail[100];
sprintf(detail, B_TRANSLATE("Version %d.%d.%d %s"),
static_cast<int>(B_TRANSLATION_MAJOR_VERSION(SGI_TRANSLATOR_VERSION)),
static_cast<int>(B_TRANSLATION_MINOR_VERSION(SGI_TRANSLATOR_VERSION)),
static_cast<int>(B_TRANSLATION_REVISION_VERSION(
SGI_TRANSLATOR_VERSION)), __DATE__);
BStringView* detailView = new BStringView("details", detail);
detailView->SetExplicitAlignment(labelAlignment);
BTextView* infoView = new BTextView("info");
infoView->SetText(BString(B_TRANSLATE("written by:\n"))
.Append(author)
.Append(B_TRANSLATE("\n\nbased on GIMP SGI plugin v1.5:\n"))
.Append(kSGICopyright).String());
infoView->SetExplicitAlignment(labelAlignment);
infoView->SetWordWrap(false);
infoView->MakeEditable(false);
infoView->MakeResizable(true);
infoView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
float padding = 5.0f;
AddChild(BGroupLayoutBuilder(B_VERTICAL, padding)
.Add(titleView)
.Add(detailView)
.Add(fCompressionMF)
.Add(infoView)
.AddGlue()
.SetInsets(padding, padding, padding, padding)
);
BFont font;
GetFont(&font);
SetExplicitPreferredSize(
BSize((font.Size() * 390) / 12, (font.Size() * 180) / 12));
// TODO: remove this workaround for ticket #4217
infoView->SetExplicitPreferredSize(
BSize(infoView->LineWidth(4), infoView->TextHeight(0, 80)));
infoView->SetExplicitMaxSize(infoView->ExplicitPreferredSize());
infoView->SetExplicitMinSize(infoView->ExplicitPreferredSize());
}
/*! \brief Constructor of CategoryPreferencesView
* \details It's a descendant of BView.
* \param[in] frame The frame rectangle of the view.
*/
CategoryPreferencesView::CategoryPreferencesView( BRect frame )
:
BView( frame,
"Category Preferences",
B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE )
{
BLayoutItem* layoutItem = NULL;
BMessage* toSend = NULL;
menuField = NULL;
this->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
/*! \note Layout of the view
* The view has a grid layout. It's arranged in the following way:
* 1) Left column - list of Categories (CategoryList) that
* contains all categories currently available.
* 2) Right column - three buttons, from top to bottom:
* 2a) Edit currently selected category - guess what it's doing
* 2b) Add a new category
* 2c) Merge a current directory into another one + menu with
* all categories. The category selected in the list is disabled.
* \note Restrictions:
* a) The list of categories is scrolled.
* b) If no category is selected, then
* i) "Edit" button is disabled
* ii) "Merge to" field is disabled
*
*/
BGridLayout* gridLayout = new BGridLayout();
if ( !gridLayout )
{
/* Panic! */
exit( 1 );
}
// Margins from the sides of the view and spacing between the elements
gridLayout->SetInsets( 5, 5, 5, 5 );
gridLayout->SetHorizontalSpacing( 10 );
gridLayout->SetVerticalSpacing( 10 );
this->SetLayout( gridLayout );
gridLayout->SetExplicitAlignment( BAlignment( B_ALIGN_USE_FULL_WIDTH, B_ALIGN_USE_FULL_HEIGHT ) );
gridLayout->SetExplicitMinSize( BSize( (this->Bounds()).Width(), (this->Bounds()).Height() ) );
BRect rect = gridLayout->Frame();
printf ( "The frame is %d pixels wide and %d pixels high.\n",
(int )rect.Width(),
(int )rect.Height() );
/* Creating the CategoryListView with its scroller */
BRect r( this->Bounds() );
r.InsetBySelf( 5, 10 ); // Margins near the border of the view
r.right = (int)(r.right / 2) - B_V_SCROLL_BAR_WIDTH;
r.bottom -= 0;
listView = new CategoryListView( r, "List View" );
if ( ! listView ) {
/* Panic! */
exit( 1 );
}
BLooper* looper = this->Looper();
if ( looper && looper->LockLooper() )
{
looper->AddHandler( ( BHandler* )this );
looper->UnlockLooper();
}
scroller = new BScrollView( "Scroller",
listView,
B_FOLLOW_LEFT | B_FOLLOW_TOP,
0, // Flags
true,
true );
if ( !scroller )
{
/* Panic! */
exit( 1 );
}
layoutItem = gridLayout->AddView( scroller, 0, 0, 1, 3 );
if ( !layoutItem ) {
/* Panic! */
exit( 1 );
}
layoutItem->SetExplicitAlignment( BAlignment( B_ALIGN_LEFT,
B_ALIGN_USE_FULL_HEIGHT ) );
toSend = new BMessage( kCategoryInvoked );
if ( !toSend )
{
/* Panic! */
exit( 1 );
}
listView->SetInvocationMessage( toSend );
toSend = new BMessage( kCategorySelected );
if ( !toSend )
{
/* Panic! */
exit( 1 );
}
listView->SetSelectionMessage( toSend );
r = listView->Bounds();
r.bottom += B_H_SCROLL_BAR_HEIGHT + 3;
r.right -= ( B_V_SCROLL_BAR_WIDTH + 10 );
layoutItem->SetExplicitMinSize( BSize( ( B_V_SCROLL_BAR_WIDTH * 2 ), r.Height() ) );
gridLayout->SetMaxColumnWidth( 0, r.Width()-70 );
gridLayout->SetMaxColumnWidth( 1, r.Width()-66 );
// Add categories to the list
PopulateCategoriesView();
/* Creating the buttons */
// Add new category button
toSend = new BMessage( kAddNewCategory );
addButton = new BButton( BRect( 0, 0, 1, 1),
"Add category",
"Add category",
toSend,
B_FOLLOW_H_CENTER | B_FOLLOW_V_CENTER );
if ( !toSend || !addButton ) {
/* Panic! */
exit( 1 );
}
addButton->ResizeToPreferred();
addButton->SetTarget( this );
layoutItem = gridLayout->AddView( addButton, 1, 0, 1, 1 );
layoutItem->SetExplicitAlignment( BAlignment( B_ALIGN_HORIZONTAL_CENTER, B_ALIGN_VERTICAL_CENTER ) );
// Edit old category button
toSend = new BMessage( kCategoryInvoked );
editButton = new BButton( BRect( 0, 0, 1, 1),
"Edit category",
"Edit category",
toSend,
B_FOLLOW_H_CENTER | B_FOLLOW_V_CENTER );
if ( !toSend || !editButton ) {
/* Panic! */
exit( 1 );
}
editButton->ResizeToPreferred();
editButton->SetTarget( this );
layoutItem = gridLayout->AddView( editButton, 1, 1, 1, 1 );
layoutItem->SetExplicitAlignment( BAlignment( B_ALIGN_HORIZONTAL_CENTER, B_ALIGN_VERTICAL_CENTER ) );
// Edit category button is disabled by default;
// it's enabled when user chooses a category in the list.
editButton->SetEnabled( false );
/* Creating the menu of merging a category */
// Create a label
BGroupLayout* groupLayout = new BGroupLayout( B_VERTICAL );
if ( !groupLayout )
{
/* Panic! */
exit( 1 );
}
gridLayout->AddItem( groupLayout, 1, 2, 1, 1 );
groupLayout->SetExplicitAlignment( BAlignment( B_ALIGN_LEFT, B_ALIGN_TOP ) );
mergeToLabel = new BStringView( BRect( 0, 0, 1, 1 ),
"Merge to label",
"Merge selected category into:" );
if ( !mergeToLabel ) {
/* Panic! */
exit( 1 );
}
mergeToLabel->ResizeToPreferred();
layoutItem = groupLayout->AddView( mergeToLabel );
layoutItem->SetExplicitAlignment( BAlignment( B_ALIGN_LEFT, B_ALIGN_TOP ) );
// Create the menu
BMessage templateMessage( kMergeIntoCategory );
listMenu = new CategoryMenu( "Select category to merge to:", true, &templateMessage );
if ( !listMenu )
{
/* Panic! */
exit( 1 );
}
menuField = new BMenuField( mergeToLabel->Bounds(),
"Merge to field",
NULL,
listMenu );
if ( !menuField ) {
/* Panic! */
exit( 1 );
}
menuField->SetDivider( 0 );
// Just like the "Edit" button above, the menu is initially disabled.
menuField->SetEnabled( false );
layoutItem = groupLayout->AddView( menuField );
layoutItem->SetExplicitAlignment( BAlignment( B_ALIGN_USE_FULL_WIDTH, B_ALIGN_TOP ) );
for ( int index = 0; index < gridLayout->CountColumns(); ++index )
{
gridLayout->SetColumnWeight( index, 1 );
}
for ( int index = 0; index < gridLayout->CountRows(); ++index )
{
gridLayout->SetRowWeight( index, 1 );
}
gridLayout->InvalidateLayout();
} // <-- end of constructor of CategoryPreferencesView
MediaConverterWindow::MediaConverterWindow(BRect frame)
:
BWindow(frame, B_TRANSLATE_SYSTEM_NAME("MediaConverter"),
B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, B_NOT_ZOOMABLE
| B_NOT_V_RESIZABLE | B_ASYNCHRONOUS_CONTROLS
| B_AUTO_UPDATE_SIZE_LIMITS),
fVideoQuality(75),
fAudioQuality(75),
fSaveFilePanel(NULL),
fOpenFilePanel(NULL),
fOutputDirSpecified(false),
fEnabled(true),
fConverting(false),
fCancelling(false)
{
BPath outputDir;
if (find_directory(B_USER_DIRECTORY, &outputDir) != B_OK)
outputDir.SetTo("/boot/home");
fOutputDir.SetTo(outputDir.Path());
fMenuBar = new BMenuBar("menubar");
_CreateMenu();
float padding = be_control_look->DefaultItemSpacing();
fListView = new MediaFileListView();
fListView->SetExplicitMinSize(BSize(padding * kMinSourceWidth, B_SIZE_UNSET));
BScrollView* scroller = new BScrollView(NULL, fListView, 0, false, true);
// file list view box
fSourcesBox = new BBox(B_FANCY_BORDER, scroller);
fSourcesBox->SetLayout(new BGroupLayout(B_HORIZONTAL, 0));
// fSourcesBox's layout adjusted in _UpdateLabels
// info box
fInfoView = new MediaFileInfoView();
fInfoView->SetExplicitAlignment(BAlignment(B_ALIGN_USE_FULL_WIDTH,
B_ALIGN_VERTICAL_UNSET));
fInfoBox = new BBox(B_FANCY_BORDER, fInfoView);
// output menu fields
fFormatMenu = new BMenuField(NULL, B_TRANSLATE("File format:"),
new BPopUpMenu(""));
fAudioMenu = new BMenuField(NULL, B_TRANSLATE("Audio encoding:"),
new BPopUpMenu(""));
fVideoMenu = new BMenuField(NULL, B_TRANSLATE("Video encoding:"),
new BPopUpMenu(""));
// output folder
fDestButton = new BButton(B_TRANSLATE("Output folder"),
new BMessage(OUTPUT_FOLDER_MESSAGE));
BAlignment labelAlignment(be_control_look->DefaultLabelAlignment());
fOutputFolder = new BStringView(NULL, outputDir.Path());
fOutputFolder->SetExplicitAlignment(labelAlignment);
// start/end duration
fStartDurationTC = new BTextControl(NULL, "0", NULL);
BLayoutItem* startDuration = fStartDurationTC->CreateTextViewLayoutItem();
startDuration->SetExplicitSize(BSize(padding * kDurationWidth, B_SIZE_UNSET));
startDuration->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_CENTER));
fEndDurationTC = new BTextControl(NULL, "0", NULL);
BLayoutItem* endDuration = fEndDurationTC->CreateTextViewLayoutItem();
endDuration->SetExplicitSize(BSize(padding * kDurationWidth, B_SIZE_UNSET));
endDuration->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_CENTER));
// video quality
fVideoQualitySlider = new BSlider("VSlider", "" ,
new BMessage(VIDEO_QUALITY_CHANGED_MESSAGE), 1, 100, B_HORIZONTAL);
fVideoQualitySlider->SetModificationMessage(
new BMessage(VIDEO_QUALITY_CHANGED_MESSAGE));
fVideoQualitySlider->SetValue(fVideoQuality);
fVideoQualitySlider->SetEnabled(false);
fVideoQualitySlider->SetExplicitSize(BSize(padding * kQualitySliderWidth,
B_SIZE_UNSET));
// audio quality
fAudioQualitySlider = new BSlider("ASlider", "" ,
new BMessage(AUDIO_QUALITY_CHANGED_MESSAGE), 1, 100, B_HORIZONTAL);
fAudioQualitySlider->SetModificationMessage(
new BMessage(AUDIO_QUALITY_CHANGED_MESSAGE));
fAudioQualitySlider->SetValue(fAudioQuality);
fAudioQualitySlider->SetEnabled(false);
fAudioQualitySlider->SetExplicitSize(BSize(padding * kQualitySliderWidth,
B_SIZE_UNSET));
// output format box
BView* outputGrid = BLayoutBuilder::Grid<>()
.Add(fFormatMenu->CreateLabelLayoutItem(), 0, 0)
.Add(fFormatMenu->CreateMenuBarLayoutItem(), 1, 0)
.Add(fAudioMenu->CreateLabelLayoutItem(), 0, 1)
.Add(fAudioMenu->CreateMenuBarLayoutItem(), 1, 1)
.Add(fVideoMenu->CreateLabelLayoutItem(), 0, 2)
.Add(fVideoMenu->CreateMenuBarLayoutItem(), 1, 2)
.Add(fDestButton, 0, 3)
.Add(fOutputFolder, 1, 3)
.Add(fStartDurationTC->CreateLabelLayoutItem(), 0, 4)
.Add(startDuration, 1, 4)
.Add(fEndDurationTC->CreateLabelLayoutItem(), 0, 5)
.Add(endDuration, 1, 5)
.Add(fVideoQualitySlider, 0, 6, 2, 1)
.Add(fAudioQualitySlider, 0, 7, 2, 1)
.View();
outputGrid->SetExplicitAlignment(BAlignment(B_ALIGN_USE_FULL_WIDTH,
B_ALIGN_USE_FULL_HEIGHT));
fOutputBox = new OutputBox(B_FANCY_BORDER, outputGrid);
fOutputBox->SetLayout(new BGroupLayout(B_HORIZONTAL, 0));
// fOutputBox's layout adjusted in _UpdateLabels
// buttons
fPreviewButton = new BButton(B_TRANSLATE("Preview"),
new BMessage(PREVIEW_MESSAGE));
fPreviewButton->SetEnabled(false);
fConvertButton = new BButton(B_TRANSLATE("Convert"),
new BMessage(CONVERT_BUTTON_MESSAGE));
// Status views
fStatus = new BStringView(NULL, NULL);
fStatus->SetExplicitAlignment(labelAlignment);
fFileStatus = new BStringView(NULL, NULL);
fFileStatus->SetExplicitAlignment(labelAlignment);
SetStatusMessage("");
_UpdateLabels();
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.SetInsets(0, 0, 0, 0)
.Add(fMenuBar)
.AddSplit(B_HORIZONTAL, padding / 2)
.SetInsets(padding, padding, padding, padding)
.Add(fSourcesBox, 0.4)
.AddGroup(B_VERTICAL, padding, 0.6)
.Add(fInfoBox)
.Add(fOutputBox)
.End()
.End()
.AddGrid(padding, padding)
.SetInsets(padding, 0, padding, padding)
.Add(fStatus, 0, 0)
.Add(fFileStatus, 0, 1)
.Add(BSpaceLayoutItem::CreateGlue(), 1, 0)
.Add(fPreviewButton, 2, 0)
.Add(fConvertButton, 3, 0)
.End();
}
TemplateWindow::TemplateWindow(const BRect& frame)
:
BWindow(frame, TR("Choose a project type"), B_TITLED_WINDOW,
B_NOT_RESIZABLE | B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS)
{
RegisterWindow();
CheckTemplates();
DPath templatePath(gAppPath.GetFolder());
templatePath << TR("Templates");
fTempList.ScanFolder(templatePath.GetFullPath());
// project type
BPopUpMenu* projectTypeMenu = new BPopUpMenu("Project type");
for (int32 i = 0; i < fTempList.CountTemplates(); i++) {
ProjectTemplate* ptemp = fTempList.TemplateAt(i);
entry_ref ref = ptemp->GetRef();
projectTypeMenu->AddItem(new BMenuItem(ref.name,
new BMessage(M_TEMPLATE_SELECTED)));
}
projectTypeMenu->ItemAt(0L)->SetMarked(true);
fTemplateField = new BMenuField("templatefield", TR("Project type: "),
projectTypeMenu);
fTemplateField->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
// project name
fNameBox = new AutoTextControl("namebox", TR("Project name:"), "",
new BMessage(M_NAME_CHANGED));
SetToolTip(fNameBox, TR("The name of your project. "
"It can be the same as the Target name, but it does not have to be."));
// target name
fTargetBox = new AutoTextControl("targetbox", TR("Target name:"), "BeApp",
new BMessage(M_TARGET_CHANGED));
SetToolTip(fTargetBox, TR("The name of the compiled application or library"));
// project path
fPathBox = new PathBox("pathbox", gProjectPath.GetFullPath(), "");
fPathBox->SetExplicitMinSize(BSize(be_plain_font->StringWidth("M") * 36,
B_SIZE_UNSET)),
SetToolTip(fPathBox, TR("Set the location for your project."));
// source control
BPopUpMenu* scmMenu = new BPopUpMenu("SCM Chooser");
scmMenu->AddItem(new BMenuItem(TR("Mercurial"), new BMessage()));
scmMenu->AddItem(new BMenuItem(TR("Git"), new BMessage()));
scmMenu->AddItem(new BMenuItem(TR("Subversion"), new BMessage()));
scmMenu->AddItem(new BMenuItem(TR("None"), new BMessage()));
if (!gHgAvailable) {
scmMenu->ItemAt(0)->SetEnabled(false);
scmMenu->ItemAt(0)->SetLabel(TR("Mercurial unavailable"));
}
if (!gGitAvailable) {
scmMenu->ItemAt(1)->SetEnabled(false);
scmMenu->ItemAt(1)->SetLabel(TR("Git unavailable"));
}
if (!gSvnAvailable) {
scmMenu->ItemAt(2)->SetEnabled(false);
scmMenu->ItemAt(2)->SetLabel(TR("Subversion unavailable"));
}
fSCMChooser = new BMenuField("scmchooser", TR("Source control: "), scmMenu);
fSCMChooser->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
SetToolTip(fSCMChooser,
TR("Choose the source control manager for your project, if any."));
scmMenu->ItemAt(gDefaultSCM)->SetMarked(true);
BMenuItem* item = scmMenu->FindMarked();
if (!item->IsEnabled()) {
item->SetMarked(false);
for (int32 i = 0; i < scmMenu->CountItems(); i++) {
if (scmMenu->ItemAt(i)->IsEnabled()) {
scmMenu->ItemAt(i)->SetMarked(true);
break;
}
}
}
// create folder check box
fCreateFolder = new BCheckBox(TR("Create project folder"));
fCreateFolder->SetValue(B_CONTROL_ON);
SetToolTip(fCreateFolder, TR("If checked, a folder for your project will be created "
"in the folder in the Location box above."));
// create project button
fCreateProjectButton = new BButton("ok", TR("Create project") B_UTF8_ELLIPSIS,
new BMessage(M_CREATE_PROJECT));
fCreateProjectButton->SetEnabled(false);
fCreateProjectButton->MakeDefault(true);
// layout
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGrid(B_USE_DEFAULT_SPACING, B_USE_SMALL_SPACING)
.Add(fTemplateField->CreateLabelLayoutItem(), 0, 0)
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING, 1, 0)
.Add(fTemplateField->CreateMenuBarLayoutItem())
.AddGlue()
.End()
.Add(fNameBox->CreateLabelLayoutItem(), 0, 1)
.Add(fNameBox->CreateTextViewLayoutItem(), 1, 1)
.Add(fTargetBox->CreateLabelLayoutItem(), 0, 2)
.Add(fTargetBox->CreateTextViewLayoutItem(), 1, 2)
.Add(new BStringView("location", TR("Location:")), 0, 3)
.Add(fPathBox, 1, 3)
.Add(fSCMChooser->CreateLabelLayoutItem(), 0, 4)
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING, 1, 4)
.Add(fSCMChooser->CreateMenuBarLayoutItem())
.AddGlue()
.End()
.Add(fCreateFolder, 1, 5)
.End()
.AddGlue()
.AddGroup(B_HORIZONTAL)
.AddGlue()
.Add(fCreateProjectButton)
.End()
.SetInsets(B_USE_DEFAULT_SPACING)
.End();
fNameBox->MakeFocus(true);
CenterOnScreen();
}
IPSettingsView::IPSettingsView(BNetworkInterface *interface, Settings *settings)
:
BView("IPSettingsView", 0, NULL)
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fSocket = socket(AF_INET, SOCK_DGRAM, 0);
fInterface = interface;
fSettings = settings;
// build the GUI
BGroupLayout* rootLayout = new BGroupLayout(B_VERTICAL);
SetLayout(rootLayout);
BGridView* controlsGroup = new BGridView();
BGridLayout* layout = controlsGroup->GridLayout();
// insets
float inset = ceilf(be_plain_font->Size() * 0.7);
rootLayout->SetInsets(inset, inset, inset, inset);
rootLayout->SetSpacing(inset);
layout->SetSpacing(inset, inset);
BPopUpMenu* modeMenu = new BPopUpMenu("modes");
modeMenu->AddItem(new BMenuItem(B_TRANSLATE("Static"),
new BMessage(kMsgStaticMode)));
modeMenu->AddItem(new BMenuItem(B_TRANSLATE("DHCP"),
new BMessage(kMsgDHCPMode)));
modeMenu->AddSeparatorItem();
modeMenu->AddItem(new BMenuItem(B_TRANSLATE("Disabled"),
new BMessage(kMsgDisabledMode)));
BPopUpMenu* networkMenu = new BPopUpMenu("networks");
fNetworkMenuField = new BMenuField(B_TRANSLATE("Network:"), networkMenu);
layout->AddItem(fNetworkMenuField->CreateLabelLayoutItem(), 0, 1);
layout->AddItem(fNetworkMenuField->CreateMenuBarLayoutItem(), 1, 1);
fTypeMenuField = new BMenuField(B_TRANSLATE("Mode:"), modeMenu);
layout->AddItem(fTypeMenuField->CreateLabelLayoutItem(), 0, 2);
layout->AddItem(fTypeMenuField->CreateMenuBarLayoutItem(), 1, 2);
fIPTextControl = new BTextControl(B_TRANSLATE("IP address:"), "", NULL);
SetupTextControl(fIPTextControl);
BLayoutItem* layoutItem = fIPTextControl->CreateTextViewLayoutItem();
layoutItem->SetExplicitMinSize(BSize(
fIPTextControl->StringWidth("XXX.XXX.XXX.XXX") + inset,
B_SIZE_UNSET));
layout->AddItem(fIPTextControl->CreateLabelLayoutItem(), 0, 3);
layout->AddItem(layoutItem, 1, 3);
fNetMaskTextControl = new BTextControl(B_TRANSLATE("Netmask:"), "", NULL);
SetupTextControl(fNetMaskTextControl);
layout->AddItem(fNetMaskTextControl->CreateLabelLayoutItem(), 0, 4);
layout->AddItem(fNetMaskTextControl->CreateTextViewLayoutItem(), 1, 4);
fGatewayTextControl = new BTextControl(B_TRANSLATE("Gateway:"), "", NULL);
SetupTextControl(fGatewayTextControl);
layout->AddItem(fGatewayTextControl->CreateLabelLayoutItem(), 0, 5);
layout->AddItem(fGatewayTextControl->CreateTextViewLayoutItem(), 1, 5);
// TODO: Replace the DNS text controls by a BListView with add/remove
// functionality and so on...
fPrimaryDNSTextControl = new BTextControl(B_TRANSLATE("DNS #1:"), "",
NULL);
SetupTextControl(fPrimaryDNSTextControl);
layout->AddItem(fPrimaryDNSTextControl->CreateLabelLayoutItem(), 0, 6);
layout->AddItem(fPrimaryDNSTextControl->CreateTextViewLayoutItem(), 1, 6);
fSecondaryDNSTextControl = new BTextControl(B_TRANSLATE("DNS #2:"), "",
NULL);
SetupTextControl(fSecondaryDNSTextControl);
layout->AddItem(fSecondaryDNSTextControl->CreateLabelLayoutItem(), 0, 7);
layout->AddItem(fSecondaryDNSTextControl->CreateTextViewLayoutItem(), 1, 7);
fDomainTextControl = new BTextControl(B_TRANSLATE("Domain:"), "", NULL);
SetupTextControl(fDomainTextControl);
layout->AddItem(fDomainTextControl->CreateLabelLayoutItem(), 0, 8);
layout->AddItem(fDomainTextControl->CreateTextViewLayoutItem(), 1, 8);
fErrorMessage = new BStringView("error", "");
fErrorMessage->SetAlignment(B_ALIGN_LEFT);
fErrorMessage->SetFont(be_bold_font);
fErrorMessage->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
layout->AddView(fErrorMessage, 1, 9);
// button group (TODO: move to window, but take care of
// enabling/disabling)
BGroupView* buttonGroup = new BGroupView(B_HORIZONTAL);
fRevertButton = new BButton(B_TRANSLATE("Revert"),
new BMessage(kMsgRevert));
fRevertButton->SetEnabled(false);
buttonGroup->GroupLayout()->AddView(fRevertButton);
buttonGroup->GroupLayout()->AddItem(BSpaceLayoutItem::CreateGlue());
fApplyButton = new BButton(B_TRANSLATE("Apply"), new BMessage(kMsgApply));
fApplyButton->SetEnabled(false);
buttonGroup->GroupLayout()->AddView(fApplyButton);
rootLayout->AddView(controlsGroup);
rootLayout->AddView(buttonGroup);
}
// This is used to do the initial toolbar creation
bool EV_BeOSToolbar::synthesize(void)
{
//Add the toolbar(s) beneath the menus ...
be_Window *pBWin = NULL;
if (!m_pBeOSFrame)
return false;
pBWin = (be_Window *)m_pBeOSFrame->getTopLevelWindow();
UT_ASSERT(pBWin);
ToolbarView *tb = new ToolbarView(this, "Toolbar",
B_WILL_DRAW | B_FRAME_EVENTS);
tb->SetExplicitMaxSize(BSize(B_SIZE_UNSET, 32));
m_pTBView = tb;
pBWin->AddChild(tb);
// create a toolbar from the info provided.
const EV_Toolbar_ActionSet * pToolbarActionSet = m_pBeOSApp->getToolbarActionSet();
UT_ASSERT(pToolbarActionSet);
XAP_Toolbar_ControlFactory * pFactory = m_pBeOSApp->getControlFactory();
UT_ASSERT(pFactory);
UT_uint32 nrLabelItemsInLayout = m_pToolbarLayout->getLayoutItemCount();
UT_ASSERT(nrLabelItemsInLayout > 0);
// Allow the user to control if we show text or icons or both ...
#if 0
const XML_Char * szValue = NULL;
m_pBeOSApp->getPrefsValue(XAP_PREF_KEY_ToolbarAppearance,&szValue);
UT_ASSERT((szValue) && (*szValue));
GtkToolbarStyle style = GTK_TOOLBAR_ICONS;
if (UT_XML_stricmp(szValue,"icon")==0)
style = GTK_TOOLBAR_ICONS;
else if (UT_XML_stricmp(szValue,"text")==0)
style = GTK_TOOLBAR_TEXT;
else if (UT_XML_stricmp(szValue,"both")==0)
style = GTK_TOOLBAR_BOTH;
#endif
for (UT_uint32 k=0; (k < nrLabelItemsInLayout); k++)
{
EV_Toolbar_LayoutItem * pLayoutItem = m_pToolbarLayout->getLayoutItem(k);
UT_ASSERT(pLayoutItem);
XAP_Toolbar_Id id = pLayoutItem->getToolbarId();
EV_Toolbar_Action * pAction = pToolbarActionSet->getAction(id);
UT_ASSERT(pAction);
EV_Toolbar_Label * pLabel = m_pToolbarLabelSet->getLabel(id);
UT_ASSERT(pLabel);
switch (pLayoutItem->getToolbarLayoutFlags()) {
case EV_TLF_Normal: {
const char * szToolTip = pLabel->getToolTip();
if (!szToolTip || !*szToolTip)
szToolTip = pLabel->getStatusMsg();
switch (pAction->getItemType()) {
case EV_TBIT_ColorFore:
case EV_TBIT_ColorBack: {
UT_ASSERT(UT_stricmp(pLabel->getIconName(),"NoIcon")!=0);
BBitmap * bitmap = m_pBeOSToolbarIcons->GetIconBitmap(pLabel->getIconName());
tb->AddItem(bitmap, NULL, id, szToolTip);
}
break;
case EV_TBIT_PushButton: {
DPRINTF(printf("EVTOOLBAR: Push button \n"));
UT_ASSERT(UT_stricmp(pLabel->getIconName(),"NoIcon")!=0);
BBitmap * bitmap = m_pBeOSToolbarIcons->GetIconBitmap(pLabel->getIconName());
//UT_ASSERT(bitmap);
//Add the bitmap to the toolbar
tb->AddItem(bitmap, NULL, id , szToolTip);
}
break;
case EV_TBIT_GroupButton:
DPRINTF(printf("EVTOOLBAR: Group Button \n"));
case EV_TBIT_ToggleButton: {
DPRINTF(printf("EVTOOLBAR: Toggle button \n"));
UT_ASSERT(UT_stricmp(pLabel->getIconName(),"NoIcon")!=0);
BBitmap * bitmap = m_pBeOSToolbarIcons->GetIconBitmap(pLabel->getIconName());
//UT_ASSERT(bitmap);
//Add the bitmap to the toolbar
tb->AddItem(bitmap, NULL, id , szToolTip);
}
break;
case EV_TBIT_ComboBox: {
DPRINTF(printf("EVTOOLBAR: Combo Box \n"));
EV_Toolbar_Control * pControl = pFactory->getControl(this, id);
UT_ASSERT(pControl);
//Add a combo type box ...
BPopUpMenu *popupmenu = new BPopUpMenu("");
UT_ASSERT(popupmenu);
// populate it
int iWidth = 100;
if (pControl) {
iWidth = pControl->getPixelWidth();
pControl->populate();
const UT_GenericVector<const char*> * v = pControl->getContents();
UT_ASSERT(v);
if (v) {
UT_uint32 items = v->getItemCount();
for (UT_uint32 m=0; m < items; m++) {
char * sz = (char *)v->getNthItem(m);
BMessage *togo = new BMessage('ddwn');
togo->AddInt32("id", id);
togo->AddInt32("item", m);
BMenuItem *newmenu = new BMenuItem(sz, togo);
UT_ASSERT(newmenu);
newmenu->SetTarget(tb);
popupmenu->AddItem(newmenu);
}
}
}
//Stick it in the menu
tb->AddItem(popupmenu, iWidth, id);
}
break;
case EV_TBIT_EditText:
case EV_TBIT_DropDown:
case EV_TBIT_StaticLabel:
case EV_TBIT_Spacer:
break;
case EV_TBIT_BOGUS:
default:
UT_ASSERT(0);
break;
}
}
break;
case EV_TLF_Spacer: {
tb->AddSeperator();
break;
}
default:
UT_ASSERT(0);
}
}
return true;
}
ShowImageWindow::ShowImageWindow(BRect frame, const entry_ref& ref,
const BMessenger& trackerMessenger)
:
BWindow(frame, "", B_DOCUMENT_WINDOW, B_AUTO_UPDATE_SIZE_LIMITS),
fNavigator(ref, trackerMessenger),
fSavePanel(NULL),
fBar(NULL),
fBrowseMenu(NULL),
fGoToPageMenu(NULL),
fSlideShowDelayMenu(NULL),
fToolBar(NULL),
fImageView(NULL),
fStatusView(NULL),
fProgressWindow(new ProgressWindow()),
fModified(false),
fFullScreen(false),
fShowCaption(true),
fShowToolBar(true),
fPrintSettings(NULL),
fSlideShowRunner(NULL),
fSlideShowDelay(kDefaultSlideShowDelay)
{
_ApplySettings();
SetLayout(new BGroupLayout(B_VERTICAL, 0));
// create menu bar
fBar = new BMenuBar("menu_bar");
_AddMenus(fBar);
float menuBarMinWidth = fBar->MinSize().width;
AddChild(fBar);
// Add a content view so the tool bar can be moved outside of the
// visible portion without colliding with the menu bar.
BView* contentView = new BView(BRect(), "content", B_FOLLOW_NONE, 0);
contentView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
contentView->SetExplicitMinSize(BSize(250, 100));
AddChild(contentView);
// Create the tool bar
BRect viewFrame = contentView->Bounds();
viewFrame.right -= B_V_SCROLL_BAR_WIDTH;
fToolBar = new BToolBar(viewFrame);
// Add the tool icons.
// fToolBar->AddAction(MSG_FILE_OPEN, be_app,
// tool_bar_icon(kIconDocumentOpen), B_TRANSLATE("Open" B_UTF8_ELLIPSIS));
fToolBar->AddAction(MSG_FILE_PREV, this,
tool_bar_icon(kIconGoPrevious), B_TRANSLATE("Previous file"), false);
fToolBar->AddAction(MSG_FILE_NEXT, this, tool_bar_icon(kIconGoNext),
B_TRANSLATE("Next file"), false);
BMessage* fullScreenSlideShow = new BMessage(MSG_SLIDE_SHOW);
fullScreenSlideShow->AddBool("full screen", true);
fToolBar->AddAction(fullScreenSlideShow, this,
tool_bar_icon(kIconMediaMovieLibrary), B_TRANSLATE("Slide show"),
false);
fToolBar->AddSeparator();
fToolBar->AddAction(MSG_SELECTION_MODE, this,
tool_bar_icon(kIconDrawRectangularSelection),
B_TRANSLATE("Selection mode"), false);
fToolBar->AddSeparator();
fToolBar->AddAction(kMsgOriginalSize, this,
tool_bar_icon(kIconZoomOriginal), B_TRANSLATE("Original size"), true);
fToolBar->AddAction(kMsgFitToWindow, this,
tool_bar_icon(kIconZoomFitBest), B_TRANSLATE("Fit to window"), false);
fToolBar->AddAction(MSG_ZOOM_IN, this, tool_bar_icon(kIconZoomIn),
B_TRANSLATE("Zoom in"), false);
fToolBar->AddAction(MSG_ZOOM_OUT, this, tool_bar_icon(kIconZoomOut),
B_TRANSLATE("Zoom out"), false);
fToolBar->AddSeparator();
fToolBar->AddAction(MSG_PAGE_PREV, this, tool_bar_icon(kIconPagePrevious),
B_TRANSLATE("Previous page"), false);
fToolBar->AddAction(MSG_PAGE_NEXT, this, tool_bar_icon(kIconPageNext),
B_TRANSLATE("Next page"), false);
fToolBar->AddGlue();
fToolBar->AddAction(MSG_FULL_SCREEN, this,
tool_bar_icon(kIconViewWindowed), B_TRANSLATE("Leave full screen"),
false);
fToolBar->SetActionVisible(MSG_FULL_SCREEN, false);
fToolBar->ResizeTo(viewFrame.Width(), fToolBar->MinSize().height);
contentView->AddChild(fToolBar);
if (fShowToolBar)
viewFrame.top = fToolBar->Frame().bottom + 1;
else
fToolBar->Hide();
fToolBarVisible = fShowToolBar;
viewFrame.bottom = contentView->Bounds().bottom;
viewFrame.bottom -= B_H_SCROLL_BAR_HEIGHT;
// create the image view
fImageView = new ShowImageView(viewFrame, "image_view", B_FOLLOW_ALL,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_PULSE_NEEDED
| B_FRAME_EVENTS);
// wrap a scroll view around the view
fScrollView = new BScrollView("image_scroller", fImageView,
B_FOLLOW_ALL, 0, true, true, B_PLAIN_BORDER);
contentView->AddChild(fScrollView);
fStatusView = new ShowImageStatusView(fScrollView);
fScrollView->AddChild(fStatusView);
// Update minimum window size
float toolBarMinWidth = fToolBar->MinSize().width;
SetSizeLimits(std::max(menuBarMinWidth, toolBarMinWidth), 100000, 100,
100000);
// finish creating the window
if (_LoadImage() != B_OK) {
_LoadError(ref);
Quit();
return;
}
// add View menu here so it can access ShowImageView methods
BMenu* menu = new BMenu(B_TRANSLATE_CONTEXT("View", "Menus"));
_BuildViewMenu(menu, false);
fBar->AddItem(menu);
fBar->AddItem(_BuildRatingMenu());
SetPulseRate(100000);
// every 1/10 second; ShowImageView needs it for marching ants
_MarkMenuItem(menu, MSG_SELECTION_MODE,
fImageView->IsSelectionModeEnabled());
// Tell application object to query the clipboard
// and tell this window if it contains interesting data or not
be_app_messenger.SendMessage(B_CLIPBOARD_CHANGED);
// The window will be shown on screen automatically
Run();
}
TeamMonitorWindow::TeamMonitorWindow()
:
BWindow(BRect(0, 0, 350, 100), B_TRANSLATE("Team monitor"),
B_TITLED_WINDOW_LOOK, B_MODAL_ALL_WINDOW_FEEL,
B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS
| B_CLOSE_ON_ESCAPE | B_AUTO_UPDATE_SIZE_LIMITS,
B_ALL_WORKSPACES),
fQuitting(false),
fUpdateRunner(NULL)
{
BGroupLayout* layout = new BGroupLayout(B_VERTICAL);
float inset = 10;
layout->SetInsets(inset, inset, inset, inset);
layout->SetSpacing(inset);
SetLayout(layout);
layout->View()->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fListView = new BListView("teams");
fListView->SetSelectionMessage(new BMessage(TM_SELECTED_TEAM));
BScrollView* scrollView = new BScrollView("scroll_teams", fListView,
0, B_SUPPORTS_LAYOUT, false, true, B_FANCY_BORDER);
scrollView->SetExplicitMinSize(BSize(B_SIZE_UNSET, 150));
fKillButton = new BButton("kill", B_TRANSLATE("Kill application"),
new BMessage(TM_KILL_APPLICATION));
fKillButton->SetEnabled(false);
fQuitButton = new BButton("quit", B_TRANSLATE("Quit application"),
new BMessage(TM_QUIT_APPLICATION));
fQuitButton->SetEnabled(false);
fDescriptionView = new TeamDescriptionView;
BButton* forceReboot = new BButton("force", B_TRANSLATE("Force reboot"),
new BMessage(TM_FORCE_REBOOT));
fRestartButton = new BButton("restart", B_TRANSLATE("Restart the desktop"),
new BMessage(TM_RESTART_DESKTOP));
fCancelButton = new BButton("cancel", B_TRANSLATE("Cancel"),
new BMessage(TM_CANCEL));
SetDefaultButton(fCancelButton);
BGroupLayoutBuilder(layout)
.Add(scrollView)
.AddGroup(B_HORIZONTAL)
.Add(fKillButton)
.Add(fQuitButton)
.AddGlue()
.End()
.Add(fDescriptionView)
.AddGroup(B_HORIZONTAL)
.Add(forceReboot)
.AddGlue()
.Add(fRestartButton)
.AddGlue(inset)
.Add(fCancelButton);
CenterOnScreen();
fRestartButton->Hide();
AddShortcut('T', B_COMMAND_KEY | B_OPTION_KEY,
new BMessage(kMsgLaunchTerminal));
AddShortcut('W', B_COMMAND_KEY, new BMessage(B_QUIT_REQUESTED));
gLocalizedNamePreferred
= BLocaleRoster::Default()->IsFilesystemTranslationPreferred();
gTeamMonitorWindow = this;
this->AddCommonFilter(new BMessageFilter(B_ANY_DELIVERY,
B_ANY_SOURCE, B_KEY_DOWN, FilterKeyDown));
if (be_app->Lock()) {
be_app->AddCommonFilter(new BMessageFilter(B_ANY_DELIVERY,
B_ANY_SOURCE, B_LOCALE_CHANGED, FilterLocaleChanged));
be_app->Unlock();
}
}
NetworkWindow::NetworkWindow()
:
BWindow(BRect(100, 100, 400, 400), B_TRANSLATE("Network"), B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS),
fServicesItem(NULL),
fDialUpItem(NULL),
fOtherItem(NULL)
{
// Profiles section
#if ENABLE_PROFILES
BPopUpMenu* profilesPopup = new BPopUpMenu("<none>");
_BuildProfilesMenu(profilesPopup, kMsgProfileSelected);
BMenuField* profilesMenuField = new BMenuField("profiles_menu",
B_TRANSLATE("Profile:"), profilesPopup);
profilesMenuField->SetFont(be_bold_font);
profilesMenuField->SetEnabled(false);
#endif
// Settings section
fRevertButton = new BButton("revert", B_TRANSLATE("Revert"),
new BMessage(kMsgRevert));
BMessage* message = new BMessage(kMsgToggleReplicant);
BCheckBox* showReplicantCheckBox = new BCheckBox("showReplicantCheckBox",
B_TRANSLATE("Show network status in Deskbar"), message);
showReplicantCheckBox->SetExplicitMaxSize(
BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
showReplicantCheckBox->SetValue(_IsReplicantInstalled());
fListView = new BOutlineListView("list", B_SINGLE_SELECTION_LIST,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS | B_NAVIGABLE);
fListView->SetSelectionMessage(new BMessage(kMsgItemSelected));
BScrollView* scrollView = new BScrollView("ScrollView", fListView,
0, false, true);
scrollView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
fAddOnShellView = new BView("add-on shell", 0,
new BGroupLayout(B_VERTICAL));
fAddOnShellView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fInterfaceView = new InterfaceView();
// Build the layout
BLayoutBuilder::Group<>(this, B_VERTICAL)
.SetInsets(B_USE_DEFAULT_SPACING)
#if ENABLE_PROFILES
.AddGroup(B_HORIZONTAL, B_USE_SMALL_SPACING)
.Add(profilesMenuField)
.AddGlue()
.End()
#endif
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
.Add(scrollView)
.Add(fAddOnShellView)
.End()
.Add(showReplicantCheckBox)
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
.Add(fRevertButton)
.AddGlue()
.End();
gNetworkWindow = this;
_ScanInterfaces();
_ScanAddOns();
_UpdateRevertButton();
fListView->Select(0);
_SelectItem(fListView->ItemAt(0));
// Call this manually, so that CenterOnScreen() below already
// knows the final window size.
// Set size of the list view from its contents
float width;
float height;
fListView->GetPreferredSize(&width, &height);
width += 2 * be_control_look->DefaultItemSpacing();
fListView->SetExplicitSize(BSize(width, B_SIZE_UNSET));
fListView->SetExplicitMinSize(BSize(width, std::min(height, 400.f)));
CenterOnScreen();
fSettings.StartMonitoring(this);
start_watching_network(B_WATCH_NETWORK_INTERFACE_CHANGES
| B_WATCH_NETWORK_LINK_CHANGES | B_WATCH_NETWORK_WLAN_CHANGES, this);
}
BSCWindow::BSCWindow()
:
BDirectWindow(kWindowRect, "BeScreenCapture", B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS|B_AUTO_UPDATE_SIZE_LIMITS),
fController(dynamic_cast<Controller*>(gControllerLooper)),
fCapturing(false)
{
OutputView *outputView
= new OutputView(fController);
AdvancedOptionsView *advancedView
= new AdvancedOptionsView(fController);
fStartStopButton = new BButton("Start", "Start Recording",
new BMessage(kMsgGUIStartCapture));
fStartStopButton->SetTarget(fController);
fStartStopButton->SetExplicitAlignment(BAlignment(B_ALIGN_RIGHT, B_ALIGN_MIDDLE));
fCardLayout = new BCardLayout();
BView* cardsView = new BView("status", 0, fCardLayout);
cardsView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fCardLayout->AddView(fCamStatus = new CamStatusView("CamStatusView"));
fCamStatus->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_MIDDLE));
BView* statusView = BLayoutBuilder::Group<>()
.SetInsets(B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING,
B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING)
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
.Add(fStringView = new BStringView("stringview", kEncodingString))
.Add(fStatusBar = new BStatusBar("", ""))
.End()
.View();
statusView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT, B_ALIGN_MIDDLE));
fStatusBar->SetExplicitMinSize(BSize(100, 20));
fCardLayout->AddView(statusView);
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGroup(B_VERTICAL, 1)
.SetInsets(B_USE_DEFAULT_SPACING, 1,
B_USE_DEFAULT_SPACING, 1)
.Add(fTabView = new BTabView("Tab View", B_WIDTH_FROM_LABEL))
.AddGroup(B_HORIZONTAL)
.Add(cardsView)
.Add(fStartStopButton)
.End()
.End();
fCardLayout->SetVisibleItem((int32)0);
BGroupView* outputGroup = new BGroupView(B_HORIZONTAL);
outputGroup->SetName("Output");
outputGroup->GroupLayout()->SetInsets(B_USE_DEFAULT_SPACING,
B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING);
fTabView->AddTab(outputGroup);
BLayoutBuilder::Group<>(outputGroup)
.Add(outputView);
BGroupView* advancedGroup = new BGroupView(B_HORIZONTAL);
advancedGroup->SetName("Advanced Options");
advancedGroup->GroupLayout()->SetInsets(B_USE_DEFAULT_SPACING,
B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING, B_USE_DEFAULT_SPACING);
fTabView->AddTab(advancedGroup);
BLayoutBuilder::Group<>(advancedGroup)
.Add(advancedView);
if (fController->LockLooper()) {
// controller should watch for these messages
//StartWatching(fController, kMsgGUIStartCapture);
//StartWatching(fController, kMsgGUIStopCapture);
StartWatching(fController, kSelectionWindowClosed);
advancedView->StartWatching(fController, kClipSizeChanged);
//StartWatching(fCamStatus, kMsgControllerCaptureResumed);
// watch Controller for these
fController->StartWatching(this, B_UPDATE_STATUS_BAR);
fController->StartWatching(this, B_RESET_STATUS_BAR);
fController->StartWatching(this, kMsgControllerEncodeStarted);
fController->StartWatching(this, kMsgControllerEncodeProgress);
fController->StartWatching(this, kMsgControllerEncodeFinished);
fController->StartWatching(this, kMsgControllerTargetFrameChanged);
fController->StartWatching(this, kMsgControllerCaptureStarted);
fController->StartWatching(this, kMsgControllerCaptureStopped);
fController->StartWatching(fCamStatus, kMsgControllerCaptureStarted);
fController->StartWatching(fCamStatus, kMsgControllerCaptureStopped);
fController->StartWatching(fCamStatus, kMsgControllerCapturePaused);
fController->StartWatching(fCamStatus, kMsgControllerCaptureResumed);
fController->StartWatching(outputView, kMsgControllerTargetFrameChanged);
fController->StartWatching(outputView, kMsgControllerCodecListUpdated);
fController->UnlockLooper();
}
StartWatching(outputView, kSelectionWindowClosed);
StartWatching(outputView, kClipSizeChanged);
CenterOnScreen();
}
void
BJobSetupPanel::_SetupInterface()
{
BGroupView* groupView = new BGroupView(B_VERTICAL, 10.0);
// printers
fPrinterPopUp = new BPopUpMenu("");
fPrinterPopUp->SetRadioMode(true);
fPrinterMenuField = new BMenuField("", fPrinterPopUp);
fPrinterMenuField->Menu()->SetLabelFromMarked(true);
BPrinter printer;
while (fPrinterRoster->GetNextPrinter(&printer) == B_OK) {
BMenuItem* item = new BMenuItem(printer.Name().String(), NULL);
fPrinterPopUp->AddItem(item);
if (printer == *fPrinter)
item->SetMarked(true);
}
if (fPrinterRoster->CountPrinters() > 0)
fPrinterPopUp->AddItem(new BSeparatorItem);
BMenuItem* pdf = new BMenuItem("Save as PDF file" , NULL);
fPrinterPopUp->AddItem(pdf);
if (fPrinterPopUp->FindMarked() == NULL)
pdf->SetMarked(true);
fProperties = new BButton("Properties" B_UTF8_ELLIPSIS , new BMessage('prop'));
fPrinterInfo = new BStringView("label", "");
fPrinterInfo->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
BBox* divider = new BBox(B_FANCY_BORDER, NULL);
divider->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, 1));
fPrintToFile = new BCheckBox("Print to file");
BView* view = BGroupLayoutBuilder(B_VERTICAL, 5.0)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 10.0)
.Add(fPrinterMenuField->CreateMenuBarLayoutItem())
.Add(fProperties))
.Add(BGroupLayoutBuilder(B_HORIZONTAL,5.0)
.Add(new BStringView("label", "Printer info:"))
.Add(fPrinterInfo))
.Add(divider)
.Add(fPrintToFile)
.SetInsets(10.0, 5.0, 10.0, 5.0);
BBox *box = new BBox(B_FANCY_BORDER, view);
box->SetLabel(BGroupLayoutBuilder()
.Add(new BStringView("", "Printer"))
.SetInsets(2.0, 0.0, 2.0, 0.0));
groupView->AddChild(box);
// page range
fPrintAll = new BRadioButton("Print all", new BMessage('prrg'));
fPrintAll->SetValue(B_CONTROL_ON);
fPagesFrom = new BRadioButton("Pages from:", new BMessage('prrg'));
fFirstPage = new BTextControl("", "", NULL);
_DisallowChar(fFirstPage->TextView());
fLastPage = new BTextControl("to:", "", NULL);
_DisallowChar(fLastPage->TextView());
fSelection = new BRadioButton("Print selection", new BMessage('prrg'));
fFirstPage->CreateLabelLayoutItem();
view = BGroupLayoutBuilder(B_VERTICAL, 5.0)
.Add(fPrintAll)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 5.0)
.Add(fPagesFrom)
.Add(fFirstPage->CreateTextViewLayoutItem())
.Add(fLastPage->CreateLabelLayoutItem())
.Add(fLastPage->CreateTextViewLayoutItem()))
.Add(fSelection)
.SetInsets(10.0, 5.0, 10.0, 5.0);
box = new BBox(B_FANCY_BORDER, view);
box->SetLabel(BGroupLayoutBuilder()
.Add(new BStringView("", "Page range"))
.SetInsets(2.0, 0.0, 2.0, 0.0));
// copies
fNumberOfCopies = new BTextControl("Number of copies:", "1", NULL);
_DisallowChar(fNumberOfCopies->TextView());
fCollate = new BCheckBox("Collate");
fReverse = new BCheckBox("Reverse");
BView* view2 = BGroupLayoutBuilder(B_VERTICAL, 5.0)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, 5.0)
.Add(fNumberOfCopies->CreateLabelLayoutItem())
.Add(fNumberOfCopies->CreateTextViewLayoutItem()))
.Add(fCollate)
.Add(fReverse)
.SetInsets(10.0, 5.0, 10.0, 5.0);
BBox* box2 = new BBox(B_FANCY_BORDER, view2);
box2->SetLabel(BGroupLayoutBuilder()
.Add(new BStringView("", "Copies"))
.SetInsets(2.0, 0.0, 2.0, 0.0));
groupView->AddChild(BGroupLayoutBuilder(B_HORIZONTAL, 10.0)
.Add(box)
.Add(box2));
// other
fColor = new BCheckBox("Print in color");
fDuplex = new BCheckBox("Double side printing");
view = BGroupLayoutBuilder(B_VERTICAL, 5.0)
.Add(fColor)
.Add(fDuplex)
.SetInsets(10.0, 5.0, 10.0, 5.0);
box = new BBox(B_FANCY_BORDER, view);
box->SetLabel(BGroupLayoutBuilder()
.Add(new BStringView("", "Other"))
.SetInsets(2.0, 0.0, 2.0, 0.0));
groupView->AddChild(box);
AddPanel(groupView);
SetOptionFlags(fJobPanelFlags);
}
/*! Tweaks the layout according to the configuration.
*/
void
BAlert::_Prepare()
{
// Must have at least one button
if (CountButtons() == 0)
debugger("BAlerts must have at least one button.");
float fontFactor = be_plain_font->Size() / 11.0f;
if (fIconView->Bitmap() == NULL)
fIconView->SetBitmap(_CreateTypeIcon());
if (fButtonWidth == B_WIDTH_AS_USUAL) {
float usualWidth = kButtonUsualWidth * fontFactor;
for (int32 index = 0; index < CountButtons(); index++) {
BButton* button = ButtonAt(index);
if (button->MinSize().width < usualWidth)
button->SetExplicitSize(BSize(usualWidth, B_SIZE_UNSET));
}
} else if (fButtonWidth == B_WIDTH_FROM_WIDEST) {
// Get width of widest label
float maxWidth = 0;
for (int32 index = 0; index < CountButtons(); index++) {
BButton* button = ButtonAt(index);
float width;
button->GetPreferredSize(&width, NULL);
if (width > maxWidth)
maxWidth = width;
}
for (int32 index = 0; index < CountButtons(); index++) {
BButton* button = ButtonAt(index);
button->SetExplicitSize(BSize(maxWidth, B_SIZE_UNSET));
}
}
if (fButtonSpacing == B_OFFSET_SPACING && CountButtons() > 1) {
// Insert some strut
fButtonLayout->AddItem(1, BSpaceLayoutItem::CreateHorizontalStrut(
kButtonOffsetSpacing * fontFactor));
}
// Position the alert so that it is centered vertically but offset a bit
// horizontally in the parent window's frame or, if unavailable, the
// screen frame.
float minWindowWidth = (fButtonSpacing == B_OFFSET_SPACING
? kWindowOffsetMinWidth : kWindowMinWidth) * fontFactor;
GetLayout()->SetExplicitMinSize(BSize(minWindowWidth, B_SIZE_UNSET));
ResizeToPreferred();
// Return early if we've already been moved...
if (Frame().left != 0 && Frame().right != 0)
return;
// otherwise center ourselves on-top of parent window/screen
BWindow* parent = dynamic_cast<BWindow*>(BLooper::LooperForThread(
find_thread(NULL)));
const BRect frame = parent != NULL ? parent->Frame()
: BScreen(this).Frame();
MoveTo(static_cast<BWindow*>(this)->AlertPosition(frame));
// Hidden by BAlert::AlertPosition()
}
void
PackageView::_InitView()
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
float fontHeight = be_plain_font->Size();
BTextView* packageDescriptionView = new DescriptionTextView(
"package description", fontHeight * 13);
packageDescriptionView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
packageDescriptionView->SetText(fInfo.GetDescription());
packageDescriptionView->MakeEditable(false);
packageDescriptionView->MakeSelectable(false);
BScrollView* descriptionScrollView = new BScrollView(
"package description scroll view", packageDescriptionView,
0, false, true, B_NO_BORDER);
// Install type menu field
fInstallTypes = new BPopUpMenu(B_TRANSLATE("none"));
BMenuField* installType = new BMenuField("install_type",
B_TRANSLATE("Installation type:"), fInstallTypes);
// Install type description text view
fInstallTypeDescriptionView = new DescriptionTextView(
"install type description", fontHeight * 4);
fInstallTypeDescriptionView->MakeEditable(false);
fInstallTypeDescriptionView->MakeSelectable(false);
fInstallTypeDescriptionView->SetInsets(8, 0, 0, 0);
// Left inset needs to match BMenuField text offset
fInstallTypeDescriptionView->SetText(
B_TRANSLATE("No installation type selected"));
fInstallTypeDescriptionView->SetViewColor(
ui_color(B_PANEL_BACKGROUND_COLOR));
BFont font(be_plain_font);
font.SetSize(ceilf(font.Size() * 0.85));
fInstallTypeDescriptionView->SetFontAndColor(&font);
BScrollView* installTypeScrollView = new BScrollView(
"install type description scroll view", fInstallTypeDescriptionView,
0, false, true, B_NO_BORDER);
// Destination menu field
fDestination = new BPopUpMenu(B_TRANSLATE("none"));
fDestField = new BMenuField("install_to", B_TRANSLATE("Install to:"),
fDestination);
fBeginButton = new BButton("begin_button", B_TRANSLATE("Begin"),
new BMessage(P_MSG_INSTALL));
BLayoutItem* typeLabelItem = installType->CreateLabelLayoutItem();
BLayoutItem* typeMenuItem = installType->CreateMenuBarLayoutItem();
BLayoutItem* destFieldLabelItem = fDestField->CreateLabelLayoutItem();
BLayoutItem* destFieldMenuItem = fDestField->CreateMenuBarLayoutItem();
float forcedMinWidth = be_plain_font->StringWidth("XXX") * 5;
destFieldMenuItem->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
typeMenuItem->SetExplicitMinSize(BSize(forcedMinWidth, B_SIZE_UNSET));
BAlignment labelAlignment(B_ALIGN_RIGHT, B_ALIGN_VERTICAL_UNSET);
typeLabelItem->SetExplicitAlignment(labelAlignment);
destFieldLabelItem->SetExplicitAlignment(labelAlignment);
// Build the layout
BLayoutBuilder::Group<>(this, B_VERTICAL)
.Add(descriptionScrollView)
.AddGrid(B_USE_SMALL_SPACING, B_USE_DEFAULT_SPACING)
.Add(typeLabelItem, 0, 0)
.Add(typeMenuItem, 1, 0)
.Add(installTypeScrollView, 1, 1)
.Add(destFieldLabelItem, 0, 2)
.Add(destFieldMenuItem, 1, 2)
.End()
.AddGroup(B_HORIZONTAL)
.AddGlue()
.Add(fBeginButton)
.End()
.SetInsets(B_USE_DEFAULT_SPACING)
;
fBeginButton->MakeDefault(true);
}
BSize
TAlertView::MaxSize()
{
return BSize(MinSize().width, B_SIZE_UNLIMITED);
}
void
VideoWindow::_BuildCaptureControls(BView* theView)
{
// a view to hold the video image
fVideoView = new BView("Video View", B_WILL_DRAW);
fVideoView->SetExplicitMinSize(BSize(VIDEO_SIZE_X, VIDEO_SIZE_Y));
fVideoView->SetExplicitMaxSize(BSize(VIDEO_SIZE_X, VIDEO_SIZE_Y));
// Capture controls
fCaptureSetupBox = new BBox("Capture Controls", B_WILL_DRAW);
fCaptureSetupBox->SetLabel("Capture controls");
BGridLayout *controlsLayout = new BGridLayout(kXBuffer, 0);
controlsLayout->SetInsets(10, 15, 5, 5);
fCaptureSetupBox->SetLayout(controlsLayout);
fFileName = new BTextControl("File Name", "File name:",
fFilenameSetting->Value(), new BMessage(msg_filename));
fFileName->SetTarget(BMessenger(NULL, this));
fImageFormatMenu = new BPopUpMenu("Image Format Menu");
AddTranslationItems(fImageFormatMenu, B_TRANSLATOR_BITMAP);
fImageFormatMenu->SetTargetForItems(this);
if (fImageFormatSettings->Value()
&& fImageFormatMenu->FindItem(fImageFormatSettings->Value()) != NULL) {
fImageFormatMenu->FindItem(
fImageFormatSettings->Value())->SetMarked(true);
} else if (fImageFormatMenu->FindItem("JPEG image") != NULL)
fImageFormatMenu->FindItem("JPEG image")->SetMarked(true);
else
fImageFormatMenu->ItemAt(0)->SetMarked(true);
fImageFormatSelector = new BMenuField("Format", "Format:",
fImageFormatMenu, NULL);
fCaptureRateMenu = new BPopUpMenu("Capture Rate Menu");
fCaptureRateMenu->AddItem(new BMenuItem("Every 15 seconds",
new BMessage(msg_rate_15s)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 30 seconds",
new BMessage(msg_rate_30s)));
fCaptureRateMenu->AddItem(new BMenuItem("Every minute",
new BMessage(msg_rate_1m)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 5 minutes",
new BMessage(msg_rate_5m)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 10 minutes",
new BMessage(msg_rate_10m)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 15 minutes",
new BMessage(msg_rate_15m)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 30 minutes",
new BMessage(msg_rate_30m)));
fCaptureRateMenu->AddItem(new BMenuItem("Every hour",
new BMessage(msg_rate_1h)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 2 hours",
new BMessage(msg_rate_2h)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 4 hours",
new BMessage(msg_rate_4h)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 8 hours",
new BMessage(msg_rate_8h)));
fCaptureRateMenu->AddItem(new BMenuItem("Every 24 hours",
new BMessage(msg_rate_24h)));
fCaptureRateMenu->AddItem(new BMenuItem("Never",
new BMessage(msg_rate_never)));
fCaptureRateMenu->SetTargetForItems(this);
fCaptureRateMenu->FindItem(fCaptureRateSetting->Value())->SetMarked(true);
fCaptureRateSelector = new BMenuField("Rate", "Rate:",
fCaptureRateMenu, NULL);
controlsLayout->AddItem(fFileName->CreateLabelLayoutItem(), 0, 0);
controlsLayout->AddItem(fFileName->CreateTextViewLayoutItem(), 1, 0);
controlsLayout->AddItem(fImageFormatSelector->CreateLabelLayoutItem(), 0, 1);
controlsLayout->AddItem(fImageFormatSelector->CreateMenuBarLayoutItem(), 1, 1);
controlsLayout->AddItem(fCaptureRateSelector->CreateLabelLayoutItem(), 0, 2);
controlsLayout->AddItem(fCaptureRateSelector->CreateMenuBarLayoutItem(), 1, 2);
controlsLayout->AddItem(BSpaceLayoutItem::CreateGlue(), 0, 3, 2);
// FTP setup box
fFtpSetupBox = new BBox("FTP Setup", B_WILL_DRAW);
fUploadClientMenu = new BPopUpMenu("Send to" B_UTF8_ELLIPSIS);
for (int i = 0; kUploadClient[i]; i++) {
BMessage *m = new BMessage(msg_upl_client);
m->AddInt32("client", i);
fUploadClientMenu->AddItem(new BMenuItem(kUploadClient[i], m));
}
fUploadClientMenu->SetTargetForItems(this);
fUploadClientMenu->FindItem(fUploadClientSetting->Value())->SetMarked(true);
fUploadClientSelector = new BMenuField("UploadClient", NULL,
fUploadClientMenu, NULL);
fFtpSetupBox->SetLabel("Output");
// this doesn't work with the layout manager
// fFtpSetupBox->SetLabel(fUploadClientSelector);
fUploadClientSelector->SetLabel("Type:");
BGridLayout *ftpLayout = new BGridLayout(kXBuffer, 0);
ftpLayout->SetInsets(10, 15, 5, 5);
fFtpSetupBox->SetLayout(ftpLayout);
fServerName = new BTextControl("Server", "Server:",
fServerSetting->Value(), new BMessage(msg_server));
fServerName->SetTarget(this);
fLoginId = new BTextControl("Login", "Login:"******"Password", "Password:"******"Directory", "Directory:",
fDirectorySetting->Value(), new BMessage(msg_directory));
fDirectory->SetTarget(this);
fPassiveFtp = new BCheckBox("Passive FTP", "Passive FTP",
new BMessage(msg_passiveftp));
fPassiveFtp->SetTarget(this);
fPassiveFtp->SetValue(fPassiveFtpSetting->Value());
ftpLayout->AddItem(fUploadClientSelector->CreateLabelLayoutItem(), 0, 0);
ftpLayout->AddItem(fUploadClientSelector->CreateMenuBarLayoutItem(), 1, 0);
ftpLayout->AddItem(fServerName->CreateLabelLayoutItem(), 0, 1);
ftpLayout->AddItem(fServerName->CreateTextViewLayoutItem(), 1, 1);
ftpLayout->AddItem(fLoginId->CreateLabelLayoutItem(), 0, 2);
ftpLayout->AddItem(fLoginId->CreateTextViewLayoutItem(), 1, 2);
ftpLayout->AddItem(fPassword->CreateLabelLayoutItem(), 0, 3);
ftpLayout->AddItem(fPassword->CreateTextViewLayoutItem(), 1, 3);
ftpLayout->AddItem(fDirectory->CreateLabelLayoutItem(), 0, 4);
ftpLayout->AddItem(fDirectory->CreateTextViewLayoutItem(), 1, 4);
ftpLayout->AddView(fPassiveFtp, 0, 5, 2);
fStatusLine = new BStringView("Status Line", "Waiting" B_UTF8_ELLIPSIS);
BGroupLayout *groupLayout = new BGroupLayout(B_VERTICAL);
groupLayout->SetInsets(kXBuffer, kYBuffer, kXBuffer, kYBuffer);
theView->SetLayout(groupLayout);
theView->AddChild(BSpaceLayoutItem::CreateVerticalStrut(kYBuffer));
theView->AddChild(BGroupLayoutBuilder(B_HORIZONTAL)
.Add(BSpaceLayoutItem::CreateHorizontalStrut(0.0))
.Add(fVideoView)
.Add(BSpaceLayoutItem::CreateHorizontalStrut(0.0))
);
theView->AddChild(BSpaceLayoutItem::CreateVerticalStrut(kYBuffer));
theView->AddChild(BGroupLayoutBuilder(B_HORIZONTAL, kXBuffer)
.Add(fCaptureSetupBox)
.Add(fFtpSetupBox)
);
theView->AddChild(BSpaceLayoutItem::CreateVerticalStrut(kYBuffer));
theView->AddChild(fStatusLine);
}
StatusView::StatusView()
:
BView(NULL, B_WILL_DRAW),
fCurrentFileInfo(NULL)
{
SetViewColor(kPieBGColor);
SetLowColor(kPieBGColor);
fSizeView = new BStringView(NULL, kEmptyStr);
fSizeView->SetExplicitMinSize(BSize(StringWidth("9999.99 GiB"),
B_SIZE_UNSET));
fSizeView->SetExplicitMaxSize(BSize(StringWidth("9999.99 GiB"),
B_SIZE_UNSET));
char testLabel[256];
snprintf(testLabel, sizeof(testLabel), B_TRANSLATE_COMMENT("%d files",
"For UI layouting only, use the longest plural form for your language"),
999999);
fCountView = new BStringView(NULL, kEmptyStr);
float width, height;
fCountView->GetPreferredSize(&width, &height);
fCountView->SetExplicitMinSize(BSize(StringWidth(testLabel),
B_SIZE_UNSET));
fCountView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, height));
fPathView = new BStringView(NULL, kEmptyStr);
fPathView->GetPreferredSize(&width, &height);
fPathView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, height));
fRefreshBtn = new BButton(NULL, B_TRANSLATE("Scan"),
new BMessage(kBtnRescan));
fRefreshBtn->SetExplicitMaxSize(BSize(B_SIZE_UNSET, B_SIZE_UNLIMITED));
BBox* divider1 = new BBox(BRect(), B_EMPTY_STRING, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
BBox* divider2 = new BBox(BRect(), B_EMPTY_STRING, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FRAME_EVENTS, B_FANCY_BORDER);
divider1->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, 1));
divider2->SetExplicitMaxSize(BSize(1, B_SIZE_UNLIMITED));
SetLayout(new BGroupLayout(B_VERTICAL));
AddChild(BLayoutBuilder::Group<>(B_HORIZONTAL, 0)
.AddGroup(B_VERTICAL, 0)
.Add(fPathView)
.Add(divider1)
.AddGroup(B_HORIZONTAL, 0)
.Add(fCountView)
.Add(divider2)
.Add(fSizeView)
.End()
.End()
.AddStrut(kSmallHMargin)
.Add(fRefreshBtn)
.SetInsets(kSmallVMargin, kSmallVMargin, kSmallVMargin, kSmallVMargin)
);
}
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();
}
virtual BSize MinSize()
{
BString label(_GetLabel());
return BSize(StringWidth(label) + 10, B_H_SCROLL_BAR_HEIGHT);
}
virtual BSize MinSize()
{
return BSize(12, 12);
}
AddTorrentWindow::AddTorrentWindow(TorrentObject* torrent)
: BWindow(BRect(),
"Add torrent",
B_TITLED_WINDOW_LOOK,
B_NORMAL_WINDOW_FEEL,
B_AUTO_UPDATE_SIZE_LIMITS |
B_ASYNCHRONOUS_CONTROLS |
B_NOT_ZOOMABLE |
B_NOT_RESIZABLE |
B_PULSE_NEEDED ),
fTorrent(torrent),
fCancelAdd(true)
{
SetPulseRate(1000000);
SetLayout(new BGroupLayout(B_VERTICAL));
float spacing = be_control_look->DefaultItemSpacing();
//
//
//
fInfoHeaderView = new InfoHeaderView(fTorrent);
fFileList = new BColumnListView("FileList", 0, B_PLAIN_BORDER, true);
fStartCheckBox = new BCheckBox("", "Start when added", NULL);
fCancelButton = new BButton("Cancel", new BMessage(B_QUIT_REQUESTED));
fAddButton = new BButton("Add", new BMessage(MSG_BUTTON_ADD));
fLoadingView = new BStatusBar("", "Downloading Metadata");
fLoadingView->SetBarHeight(12);
fLoadingView->SetMaxValue(1.0);
if( !fTorrent->IsMagnet() )
fLoadingView->Hide();
fStartCheckBox->SetValue(B_CONTROL_ON);
//
//
//
fFileList->SetColumnFlags(B_ALLOW_COLUMN_RESIZE);
fFileList->SetSortingEnabled(false);
fFileList->SetExplicitMinSize(BSize(550, FILE_COLUMN_HEIGHT * 5));
fFileList->AddColumn(new FileColumn("Name", 400, 400, 500), COLUMN_FILE_NAME);
fFileList->AddColumn(new CheckBoxColumn("DL", 40, 40, 40), COLUMN_FILE_DOWNLOAD);
//
// We're a magnet or a complete torrent file?
//
if( fTorrent->IsMagnet() )
{
fTorrent->SetMetadataCallbackHandler(this);
//const_cast<TorrentObject*>(fTorrent)->StartTransfer();
}
else
UpdateFileList();
AddChild(BGroupLayoutBuilder(B_VERTICAL, spacing)
.Add(fInfoHeaderView)
.AddGlue()
.Add(fFileList)
.Add(BGroupLayoutBuilder(B_HORIZONTAL, spacing)
.SetInsets(spacing, spacing, spacing, spacing)
.Add(fStartCheckBox)
.AddGlue()
.Add(fCancelButton)
.Add(fAddButton)
.Add(fLoadingView)
)
.SetInsets(spacing, spacing, spacing, spacing)
);
CenterOnScreen();
Run();
}
FilterView::FilterView()
:
BGroupView("filter view", B_VERTICAL)
{
// Contruct category popup
BPopUpMenu* showMenu = new BPopUpMenu(B_TRANSLATE("Category"));
fShowField = new BMenuField("category", B_TRANSLATE("Category:"), showMenu);
// Construct repository popup
BPopUpMenu* repositoryMenu = new BPopUpMenu(B_TRANSLATE("Depot"));
fRepositoryField = new BMenuField("repository", B_TRANSLATE("Depot:"),
repositoryMenu);
// Construct search terms field
fSearchTermsText = new BTextControl("search terms",
B_TRANSLATE("Search terms:"), "", NULL);
fSearchTermsText->SetModificationMessage(
new BMessage(MSG_SEARCH_TERMS_MODIFIED));
BSize minSearchSize = fSearchTermsText->MinSize();
float minSearchWidth
= be_plain_font->StringWidth(fSearchTermsText->Label())
+ be_plain_font->StringWidth("XXX") * 6;
minSearchWidth = std::max(minSearchSize.width, minSearchWidth);
minSearchSize.width = minSearchWidth;
fSearchTermsText->SetExplicitMinSize(minSearchSize);
float maxSearchWidth = minSearchWidth * 2;
fSearchTermsText->SetExplicitMaxSize(BSize(maxSearchWidth, B_SIZE_UNSET));
// Construct check boxen
fAvailableCheckBox = create_check_box(
B_TRANSLATE("Available"), "available");
fInstalledCheckBox = create_check_box(
B_TRANSLATE("Installed"), "installed");
fDevelopmentCheckBox = create_check_box(
B_TRANSLATE("Development"), "development");
fSourceCodeCheckBox = create_check_box(
B_TRANSLATE("Source code"), "source code");
// Build layout
BLayoutBuilder::Group<>(this)
.AddGroup(B_HORIZONTAL)
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING, 1.2f)
.Add(fShowField, 0.0f)
.Add(fRepositoryField, 0.0f)
.SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET))
.End()
.AddGlue(0.5f)
.Add(fSearchTermsText, 1.0f)
.End()
.AddGroup(B_HORIZONTAL)
.Add(fAvailableCheckBox)
.Add(fInstalledCheckBox)
.Add(fDevelopmentCheckBox)
.Add(fSourceCodeCheckBox)
.AddGlue(0.5f)
.End()
.SetInsets(B_USE_DEFAULT_SPACING)
;
}
BSize
RadioButton::MinSize()
{
return BSize(12, 12);
}
