void
CPUButton::MessageReceived(BMessage *message)
{
switch (message->what) {
case B_ABOUT_REQUESTED: {
BAlert *alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("Pulse\n\nBy David Ramsey and Arve Hjønnevåg\n"
"Revised by Daniel Switkin"), B_TRANSLATE("OK"));
// Use the asynchronous version so we don't block the window's thread
alert->Go(NULL);
break;
}
case PV_REPLICANT_PULSE: {
// Make sure we're consistent with our CPU
if (_kern_cpu_enabled(fCPU) != Value() && !IsTracking())
SetValue(!Value());
break;
}
case kDeleteReplicant: {
Window()->PostMessage(kDeleteReplicant, this, NULL);
break;
}
default:
BControl::MessageReceived(message);
break;
}
}
void PulseView::Update() {
system_info sys_info;
get_system_info(&sys_info);
bigtime_t now = system_time();
// Calculate work done since last call to Update() for each CPU
for (int x = 0; x < sys_info.cpu_count; x++) {
double cpu_time = (double)(sys_info.cpu_infos[x].active_time - prev_active[x]) / (now - prev_time);
prev_active[x] = sys_info.cpu_infos[x].active_time;
if (cpu_time < 0) cpu_time = 0;
if (cpu_time > 1) cpu_time = 1;
cpu_times[x] = cpu_time;
if (sys_info.cpu_count >= 2) {
if (!_kern_cpu_enabled(x) && cpu_menu_items[x]->IsMarked())
cpu_menu_items[x]->SetMarked(false);
if (_kern_cpu_enabled(x) && !cpu_menu_items[x]->IsMarked())
cpu_menu_items[x]->SetMarked(true);
}
}
prev_time = now;
}
bool
LastEnabledCPU(int my_cpu)
{
system_info sys_info;
get_system_info(&sys_info);
if (sys_info.cpu_count == 1)
return true;
for (int x = 0; x < sys_info.cpu_count; x++) {
if (x == my_cpu)
continue;
if (_kern_cpu_enabled(x) == 1)
return false;
}
return true;
}
int32
Filter::NumberOfActiveCPUs() const
{
int count;
system_info info;
get_system_info(&info);
count = info.cpu_count;
int32 cpuCount = 0;
for (int i = 0; i < count; i ++) {
if (_kern_cpu_enabled(i))
cpuCount++;
}
if (cpuCount == 0)
cpuCount = 1;
return cpuCount;
}
void
CPUButton::MessageReceived(BMessage *message)
{
switch (message->what) {
case B_ABOUT_REQUESTED: {
PulseApp::ShowAbout(false);
break;
}
case PV_REPLICANT_PULSE: {
// Make sure we're consistent with our CPU
if (_kern_cpu_enabled(fCPU) != Value() && !IsTracking())
SetValue(!Value());
break;
}
case kDeleteReplicant: {
Window()->PostMessage(kDeleteReplicant, this, NULL);
break;
}
default:
BControl::MessageReceived(message);
break;
}
}
long
sysconf(int name)
{
int err;
// TODO: This is about what BeOS does, better POSIX conformance would be nice, though
switch (name) {
case _SC_ARG_MAX:
return ARG_MAX;
case _SC_CHILD_MAX:
return CHILD_MAX;
case _SC_CLK_TCK:
return CLK_TCK;
case _SC_JOB_CONTROL:
return 1;
case _SC_NGROUPS_MAX:
return NGROUPS_MAX;
case _SC_OPEN_MAX:
return OPEN_MAX;
case _SC_SAVED_IDS:
return 1;
case _SC_STREAM_MAX:
return STREAM_MAX;
case _SC_TZNAME_MAX:
return TZNAME_MAX;
case _SC_VERSION:
return _POSIX_VERSION;
case _SC_GETGR_R_SIZE_MAX:
return MAX_GROUP_BUFFER_SIZE;
case _SC_GETPW_R_SIZE_MAX:
return MAX_PASSWD_BUFFER_SIZE;
case _SC_PAGE_SIZE:
return B_PAGE_SIZE;
case _SC_SEM_NSEMS_MAX:
return MAX_POSIX_SEMS;
case _SC_SEM_VALUE_MAX:
return MAX_POSIX_SEM_VALUE;
case _SC_SEMAPHORES:
return _POSIX_SEMAPHORES;
case _SC_THREADS:
return _POSIX_THREADS;
case _SC_IOV_MAX:
return IOV_MAX;
case _SC_NPROCESSORS_MAX:
return B_MAX_CPU_COUNT;
case _SC_NPROCESSORS_CONF:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
errno = err;
return -1;
}
return info.cpu_count;
}
case _SC_NPROCESSORS_ONLN:
{
system_info info;
int i;
int count = 0;
err = get_system_info(&info);
if (err < B_OK) {
errno = err;
return -1;
}
for (i = 0; i < info.cpu_count; i++)
if (_kern_cpu_enabled(i))
count++;
return count;
}
case _SC_CPUID_MAX:
return B_MAX_CPU_COUNT - 1;
case _SC_ATEXIT_MAX:
return ATEXIT_MAX;
case _SC_PASS_MAX:
break;
//XXX:return PASS_MAX;
case _SC_PHYS_PAGES:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
errno = err;
return -1;
}
return info.max_pages;
}
case _SC_AVPHYS_PAGES:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
errno = err;
return -1;
}
return info.max_pages - info.used_pages;
}
/*
case _SC_PIPE:
return 1;
case _SC_SELECT:
return 1;
case _SC_POLL:
return 1;
*/
}
errno = EINVAL;
return -1;
}
long
__sysconf(int name)
{
int err;
// TODO: This is about what BeOS does, better POSIX conformance would be
// nice, though
switch (name) {
case _SC_ARG_MAX:
return ARG_MAX;
case _SC_CHILD_MAX:
return CHILD_MAX;
case _SC_CLK_TCK:
return CLK_TCK;
case _SC_JOB_CONTROL:
return 1;
case _SC_NGROUPS_MAX:
return NGROUPS_MAX;
case _SC_OPEN_MAX:
return OPEN_MAX;
case _SC_SAVED_IDS:
return 1;
case _SC_STREAM_MAX:
return STREAM_MAX;
case _SC_TZNAME_MAX:
return TZNAME_MAX;
case _SC_VERSION:
return _POSIX_VERSION;
case _SC_GETGR_R_SIZE_MAX:
return MAX_GROUP_BUFFER_SIZE;
case _SC_GETPW_R_SIZE_MAX:
return MAX_PASSWD_BUFFER_SIZE;
case _SC_PAGE_SIZE:
return B_PAGE_SIZE;
case _SC_SEM_NSEMS_MAX:
return MAX_POSIX_SEMS;
case _SC_SEM_VALUE_MAX:
return _POSIX_SEM_VALUE_MAX;
case _SC_SEMAPHORES:
return _POSIX_SEMAPHORES;
case _SC_THREADS:
return _POSIX_THREADS;
case _SC_IOV_MAX:
return IOV_MAX;
case _SC_NPROCESSORS_MAX:
return B_MAX_CPU_COUNT;
case _SC_NPROCESSORS_CONF:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
__set_errno(err);
return -1;
}
return info.cpu_count;
}
case _SC_NPROCESSORS_ONLN:
{
system_info info;
int i;
int count = 0;
err = get_system_info(&info);
if (err < B_OK) {
__set_errno(err);
return -1;
}
for (i = 0; i < info.cpu_count; i++)
if (_kern_cpu_enabled(i))
count++;
return count;
}
case _SC_CPUID_MAX:
return B_MAX_CPU_COUNT - 1;
case _SC_ATEXIT_MAX:
return ATEXIT_MAX;
case _SC_PASS_MAX:
break;
//XXX:return PASS_MAX;
case _SC_PHYS_PAGES:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
__set_errno(err);
return -1;
}
return info.max_pages;
}
case _SC_AVPHYS_PAGES:
{
system_info info;
err = get_system_info(&info);
if (err < B_OK) {
__set_errno(err);
return -1;
}
return info.max_pages - info.used_pages;
}
case _SC_MAPPED_FILES:
return _POSIX_MAPPED_FILES;
case _SC_THREAD_PROCESS_SHARED:
return _POSIX_THREAD_PROCESS_SHARED;
case _SC_THREAD_STACK_MIN:
return MIN_USER_STACK_SIZE;
case _SC_THREAD_ATTR_STACKADDR:
return _POSIX_THREAD_ATTR_STACKADDR;
case _SC_THREAD_ATTR_STACKSIZE:
return _POSIX_THREAD_ATTR_STACKSIZE;
case _SC_THREAD_PRIORITY_SCHEDULING:
return _POSIX_THREAD_PRIORITY_SCHEDULING;
case _SC_REALTIME_SIGNALS:
return _POSIX_REALTIME_SIGNALS;
case _SC_MEMORY_PROTECTION:
return _POSIX_MEMORY_PROTECTION;
case _SC_SIGQUEUE_MAX:
return MAX_QUEUED_SIGNALS;
case _SC_RTSIG_MAX:
return SIGRTMAX - SIGRTMIN + 1;
case _SC_MONOTONIC_CLOCK:
return _POSIX_MONOTONIC_CLOCK;
case _SC_DELAYTIMER_MAX:
return MAX_USER_TIMER_OVERRUN_COUNT;
case _SC_TIMER_MAX:
return MAX_USER_TIMERS_PER_TEAM;
case _SC_TIMERS:
return _POSIX_TIMERS;
case _SC_CPUTIME:
return _POSIX_CPUTIME;
case _SC_THREAD_CPUTIME:
return _POSIX_THREAD_CPUTIME;
// not POSIX (anymore)
case _SC_PIPE:
case _SC_SELECT:
case _SC_POLL:
return 1;
}
__set_errno(EINVAL);
return -1;
}
status_t
thread_popup(void *arg)
{
Tpopup_param* param = (Tpopup_param*) arg;
int32 mcookie, hcookie;
unsigned long m;
long h;
BMenuItem* item;
bool top = param->top;
system_info systemInfo;
get_system_info(&systemInfo);
info_pack* infos = new info_pack[systemInfo.used_teams];
// TODO: this doesn't necessarily get all teams
for (m = 0, mcookie = 0; m < systemInfo.used_teams; m++) {
infos[m].team_icon = NULL;
infos[m].team_name[0] = 0;
infos[m].thread_info = NULL;
if (get_next_team_info(&mcookie, &infos[m].team_info) == B_OK) {
infos[m].thread_info = new thread_info[infos[m].team_info.thread_count];
for (h = 0, hcookie = 0; h < infos[m].team_info.thread_count; h++) {
if (get_next_thread_info(infos[m].team_info.team, &hcookie,
&infos[m].thread_info[h]) != B_OK)
infos[m].thread_info[h].thread = -1;
}
get_team_name_and_icon(infos[m], true);
} else {
systemInfo.used_teams = m;
infos[m].team_info.team = -1;
}
}
BPopUpMenu* popup = new BPopUpMenu("Global Popup", false, false);
popup->SetFont(be_plain_font);
// Quit section
BMenu* QuitPopup = new QuitMenu(B_TRANSLATE("Quit an application"),
infos, systemInfo.used_teams);
QuitPopup->SetFont(be_plain_font);
popup->AddItem(QuitPopup);
// Memory Usage section
MemoryBarMenu* MemoryPopup = new MemoryBarMenu(B_TRANSLATE("Memory usage"),
infos, systemInfo);
int64 committedMemory = (int64)systemInfo.used_pages * B_PAGE_SIZE / 1024;
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
MemoryBarMenuItem* memoryItem =
new MemoryBarMenuItem(infos[m].team_name,
infos[m].team_info.team, infos[m].team_icon, false, NULL);
MemoryPopup->AddItem(memoryItem);
memoryItem->UpdateSituation(committedMemory);
}
}
addtopbottom(MemoryPopup);
// CPU Load section
TeamBarMenu* CPUPopup = new TeamBarMenu(B_TRANSLATE("Threads and CPU "
"usage"), infos, systemInfo.used_teams);
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
ThreadBarMenu* TeamPopup = new ThreadBarMenu(infos[m].team_name,
infos[m].team_info.team, infos[m].team_info.thread_count);
BMessage* kill_team = new BMessage('KlTm');
kill_team->AddInt32("team", infos[m].team_info.team);
TeamBarMenuItem* item = new TeamBarMenuItem(TeamPopup, kill_team,
infos[m].team_info.team, infos[m].team_icon, false);
item->SetTarget(gPCView);
CPUPopup->AddItem(item);
}
}
addtopbottom(CPUPopup);
addtopbottom(new BSeparatorItem());
// CPU on/off section
if (gCPUcount > 1) {
for (unsigned int i = 0; i < gCPUcount; i++) {
char item_name[32];
sprintf (item_name, B_TRANSLATE("Processor %d"), i + 1);
BMessage* m = new BMessage ('CPU ');
m->AddInt32 ("cpu", i);
item = new IconMenuItem (gPCView->fProcessorIcon, item_name, m);
if (_kern_cpu_enabled(i))
item->SetMarked (true);
item->SetTarget(gPCView);
addtopbottom(item);
}
addtopbottom (new BSeparatorItem ());
}
// Scheduler modes
static const char* schedulerModes[] = { B_TRANSLATE_MARK("Low latency"),
B_TRANSLATE_MARK("Power saving") };
unsigned int modesCount = sizeof(schedulerModes) / sizeof(const char*);
int32 currentMode = get_scheduler_mode();
for (unsigned int i = 0; i < modesCount; i++) {
BMessage* m = new BMessage('Schd');
m->AddInt32("mode", i);
item = new BMenuItem(B_TRANSLATE(schedulerModes[i]), m);
if ((uint32)currentMode == i)
item->SetMarked(true);
item->SetTarget(gPCView);
addtopbottom(item);
}
addtopbottom(new BSeparatorItem());
if (!be_roster->IsRunning(kTrackerSig)) {
item = new IconMenuItem(gPCView->fTrackerIcon,
B_TRANSLATE("Restart Tracker"), new BMessage('Trac'));
item->SetTarget(gPCView);
addtopbottom(item);
}
if (!be_roster->IsRunning(kDeskbarSig)) {
item = new IconMenuItem(gPCView->fDeskbarIcon,
B_TRANSLATE("Restart Deskbar"), new BMessage('Dbar'));
item->SetTarget(gPCView);
addtopbottom(item);
}
item = new IconMenuItem(gPCView->fTerminalIcon,
B_TRANSLATE("New Terminal"), new BMessage('Term'));
item->SetTarget(gPCView);
addtopbottom(item);
addtopbottom(new BSeparatorItem());
bool showLiveInDeskbarItem = gInDeskbar;
if (!showLiveInDeskbarItem) {
int32 cookie = 0;
image_info info;
while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
if (info.type == B_APP_IMAGE) {
// only show the Live in Deskbar item if a) we're running in
// deskbar itself, or b) we're running in PC's team.
if (strstr(info.name, "ProcessController") != NULL) {
showLiveInDeskbarItem = true;
break;
}
}
}
}
if (showLiveInDeskbarItem && be_roster->IsRunning(kDeskbarSig)) {
item = new BMenuItem(B_TRANSLATE("Live in the Deskbar"),
new BMessage('AlDb'));
BDeskbar deskbar;
item->SetMarked(gInDeskbar || deskbar.HasItem(kDeskbarItemName));
item->SetTarget(gPCView);
addtopbottom(item);
addtopbottom(new BSeparatorItem ());
}
item = new IconMenuItem(gPCView->fProcessControllerIcon,
B_TRANSLATE("About ProcessController" B_UTF8_ELLIPSIS),
new BMessage(B_ABOUT_REQUESTED));
item->SetTarget(gPCView);
addtopbottom(item);
param->where.x -= 5;
param->where.y -= 8;
popup->Go(param->where, true, true, param->clickToOpenRect);
delete popup;
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
delete[] infos[m].thread_info;
delete infos[m].team_icon;
}
}
delete[] infos;
delete param;
atomic_add (&gPopupFlag, -1);
gPopupThreadID = 0;
return B_OK;
}
void
ProcessController::MessageReceived(BMessage *message)
{
team_id team;
thread_id thread;
BAlert *alert;
char question[1000];
switch (message->what) {
case 'Puls':
Update ();
DoDraw (false);
break;
case 'QtTm':
if (message->FindInt32("team", &team) == B_OK) {
resume_thread(spawn_thread(thread_quit_application,
B_TRANSLATE("Quit application"), B_NORMAL_PRIORITY,
(void*)(addr_t)team));
}
break;
case 'KlTm':
if (message->FindInt32("team", &team) == B_OK) {
info_pack infos;
if (get_team_info(team, &infos.team_info) == B_OK) {
get_team_name_and_icon(infos);
snprintf(question, sizeof(question),
B_TRANSLATE("What do you want to do with the team \"%s\"?"),
infos.team_name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Debug this team!"),
B_TRANSLATE("Kill this team!"), B_WIDTH_AS_USUAL,
B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
int result = alert->Go();
switch (result) {
case 1:
_HandleDebugRequest(team, -1);
break;
case 2:
kill_team(team);
break;
default:
break;
}
} else {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This team is already gone" B_UTF8_ELLIPSIS),
B_TRANSLATE("Ok!"), NULL, NULL, B_WIDTH_AS_USUAL,
B_STOP_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
}
break;
case 'KlTh':
if (message->FindInt32("thread", &thread) == B_OK) {
thread_info thinfo;
if (get_thread_info(thread, &thinfo) == B_OK) {
#if DEBUG_THREADS
snprintf(question, sizeof(question),
B_TRANSLATE("What do you want to do "
"with the thread \"%s\"?"), thinfo.name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Debug this thread!"),
B_TRANSLATE("Kill this thread!"), B_WIDTH_AS_USUAL,
B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
#define KILL 2
#else
snprintf(question, sizeof(question),
B_TRANSLATE("Are you sure you want "
"to kill the thread \"%s\"?"), thinfo.name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Kill this thread!"),
NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
#define KILL 1
#endif
alert->SetShortcut(0, B_ESCAPE);
int r = alert->Go();
if (r == KILL)
kill_thread(thread);
#if DEBUG_THREADS
else if (r == 1)
_HandleDebugRequest(thinfo.team, thinfo.thread);
#endif
} else {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This thread is already gone" B_UTF8_ELLIPSIS),
B_TRANSLATE("Ok!"), NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
}
break;
case 'PrTh':
if (message->FindInt32("thread", &thread) == B_OK) {
int32 new_priority;
if (message->FindInt32("priority", &new_priority) == B_OK)
set_thread_priority(thread, new_priority);
}
break;
case 'Trac':
{
BPath trackerPath;
if (find_directory(B_SYSTEM_DIRECTORY, &trackerPath) == B_OK
&& trackerPath.Append("Tracker") == B_OK) {
launch(kTrackerSig, trackerPath.Path());
}
break;
}
case 'Dbar':
{
BPath deskbarPath;
if (find_directory(B_SYSTEM_DIRECTORY, &deskbarPath) == B_OK
&& deskbarPath.Append("Deskbar") == B_OK) {
launch(kDeskbarSig, deskbarPath.Path());
}
break;
}
case 'Term':
{
BPath terminalPath;
if (find_directory(B_SYSTEM_APPS_DIRECTORY, &terminalPath) == B_OK
&& terminalPath.Append("Terminal") == B_OK) {
launch(kTerminalSig, terminalPath.Path());
}
break;
}
case 'AlDb':
{
if (!be_roster->IsRunning(kDeskbarSig)) {
BPath deskbarPath;
if (find_directory(B_SYSTEM_DIRECTORY, &deskbarPath) == B_OK
&& deskbarPath.Append("Deskbar") == B_OK) {
launch(kDeskbarSig, deskbarPath.Path());
}
}
BDeskbar deskbar;
if (gInDeskbar || deskbar.HasItem (kDeskbarItemName))
deskbar.RemoveItem (kDeskbarItemName);
else
move_to_deskbar(deskbar);
break;
}
case 'CPU ':
{
uint32 cpu;
if (message->FindInt32("cpu", (int32*)&cpu) == B_OK) {
bool last = true;
for (unsigned int p = 0; p < gCPUcount; p++) {
if (p != cpu && _kern_cpu_enabled(p)) {
last = false;
break;
}
}
if (last) {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This is the last active processor...\n"
"You can't turn it off!"),
B_TRANSLATE("That's no Fun!"), NULL, NULL,
B_WIDTH_AS_USUAL, B_WARNING_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
} else
_kern_set_cpu_enabled(cpu, !_kern_cpu_enabled(cpu));
}
break;
}
case 'Schd':
{
int32 mode;
if (message->FindInt32 ("mode", &mode) == B_OK)
set_scheduler_mode(mode);
break;
}
case B_ABOUT_REQUESTED:
AboutRequested();
break;
default:
BView::MessageReceived(message);
}
}
long
thread_popup(void *arg)
{
Tpopup_param* param = (Tpopup_param*) arg;
int32 mcookie, hcookie;
long m, h;
BMenuItem* item;
bool top = param->top;
system_info systemInfo;
get_system_info(&systemInfo);
info_pack* infos = new info_pack[systemInfo.used_teams];
// TODO: this doesn't necessarily get all teams
for (m = 0, mcookie = 0; m < systemInfo.used_teams; m++) {
infos[m].team_icon = NULL;
infos[m].team_name[0] = 0;
infos[m].thread_info = NULL;
if (get_next_team_info(&mcookie, &infos[m].team_info) == B_OK) {
infos[m].thread_info = new thread_info[infos[m].team_info.thread_count];
for (h = 0, hcookie = 0; h < infos[m].team_info.thread_count; h++) {
if (get_next_thread_info(infos[m].team_info.team, &hcookie,
&infos[m].thread_info[h]) != B_OK)
infos[m].thread_info[h].thread = -1;
}
get_team_name_and_icon(infos[m], true);
} else {
systemInfo.used_teams = m;
infos[m].team_info.team = -1;
}
}
BPopUpMenu* popup = new BPopUpMenu("Global Popup", false, false);
popup->SetFont(be_plain_font);
// Quit section
BMenu* QuitPopup = new QuitMenu(B_TRANSLATE("Quit an application"),
infos, systemInfo.used_teams);
QuitPopup->SetFont(be_plain_font);
popup->AddItem(QuitPopup);
// Memory Usage section
MemoryBarMenu* MemoryPopup = new MemoryBarMenu(B_TRANSLATE("Memory usage"),
infos, systemInfo);
int commitedMemory = int(systemInfo.used_pages * B_PAGE_SIZE / 1024);
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
MemoryBarMenuItem* memoryItem =
new MemoryBarMenuItem(infos[m].team_name,
infos[m].team_info.team, infos[m].team_icon, false, NULL);
MemoryPopup->AddItem(memoryItem);
memoryItem->UpdateSituation(commitedMemory);
}
}
addtopbottom(MemoryPopup);
// CPU Load section
TeamBarMenu* CPUPopup = new TeamBarMenu(B_TRANSLATE("Threads and CPU "
"usage"), infos, systemInfo.used_teams);
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
ThreadBarMenu* TeamPopup = new ThreadBarMenu(infos[m].team_name,
infos[m].team_info.team, infos[m].team_info.thread_count);
BMessage* kill_team = new BMessage('KlTm');
kill_team->AddInt32("team", infos[m].team_info.team);
TeamBarMenuItem* item = new TeamBarMenuItem(TeamPopup, kill_team,
infos[m].team_info.team, infos[m].team_icon, false);
item->SetTarget(gPCView);
CPUPopup->AddItem(item);
}
}
addtopbottom(CPUPopup);
addtopbottom(new BSeparatorItem());
// CPU on/off section
if (gCPUcount > 1) {
for (int i = 0; i < gCPUcount; i++) {
char item_name[32];
sprintf (item_name, B_TRANSLATE("Processor %d"), i + 1);
BMessage* m = new BMessage ('CPU ');
m->AddInt32 ("cpu", i);
item = new IconMenuItem (gPCView->fProcessorIcon, item_name, m);
if (_kern_cpu_enabled(i))
item->SetMarked (true);
item->SetTarget(gPCView);
addtopbottom(item);
}
addtopbottom (new BSeparatorItem ());
}
if (!be_roster->IsRunning(kTrackerSig)) {
item = new IconMenuItem(gPCView->fTrackerIcon,
B_TRANSLATE("Restart Tracker"), new BMessage('Trac'));
item->SetTarget(gPCView);
addtopbottom(item);
}
if (!be_roster->IsRunning(kDeskbarSig)) {
item = new IconMenuItem(gPCView->fDeskbarIcon,
B_TRANSLATE("Restart Deskbar"), new BMessage('Dbar'));
item->SetTarget(gPCView);
addtopbottom(item);
}
item = new IconMenuItem(gPCView->fTerminalIcon,
B_TRANSLATE("New Terminal"), new BMessage('Term'));
item->SetTarget(gPCView);
addtopbottom(item);
addtopbottom(new BSeparatorItem());
if (be_roster->IsRunning(kDeskbarSig)) {
item = new BMenuItem(B_TRANSLATE("Live in the Deskbar"),
new BMessage('AlDb'));
BDeskbar deskbar;
item->SetMarked(gInDeskbar || deskbar.HasItem(kDeskbarItemName));
item->SetTarget(gPCView);
addtopbottom(item);
addtopbottom(new BSeparatorItem ());
}
item = new IconMenuItem(gPCView->fProcessControllerIcon,
B_TRANSLATE("About ProcessController"B_UTF8_ELLIPSIS),
new BMessage(B_ABOUT_REQUESTED));
item->SetTarget(gPCView);
addtopbottom(item);
param->where.x -= 5;
param->where.y -= 8;
popup->Go(param->where, true, true, param->clickToOpenRect);
delete popup;
for (m = 0; m < systemInfo.used_teams; m++) {
if (infos[m].team_info.team >= 0) {
delete[] infos[m].thread_info;
delete infos[m].team_icon;
}
}
delete[] infos;
delete param;
atomic_add (&gPopupFlag, -1);
gPopupThreadID = 0;
return B_OK;
}
void
ProcessController::MessageReceived(BMessage *message)
{
team_id team;
thread_id thread;
BAlert *alert;
char question[1000];
switch (message->what) {
case 'Puls':
Update ();
DoDraw (false);
break;
case 'QtTm':
if (message->FindInt32("team", &team) == B_OK) {
resume_thread(spawn_thread(thread_quit_application,
B_TRANSLATE("Quit application"), B_NORMAL_PRIORITY,
(void*) team));
}
break;
case 'KlTm':
if (message->FindInt32("team", &team) == B_OK) {
info_pack infos;
if (get_team_info(team, &infos.team_info) == B_OK) {
get_team_name_and_icon(infos);
snprintf(question, sizeof(question),
B_TRANSLATE("Do you really want to kill the team \"%s\"?"),
infos.team_name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Yes, kill this team!"),
NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
if (alert->Go())
kill_team(team);
} else {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This team is already gone"B_UTF8_ELLIPSIS),
B_TRANSLATE("Ok!"), NULL, NULL, B_WIDTH_AS_USUAL,
B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
alert->Go();
}
}
break;
case 'KlTh':
if (message->FindInt32("thread", &thread) == B_OK) {
thread_info thinfo;
if (get_thread_info(thread, &thinfo) == B_OK) {
#if DEBUG_THREADS
snprintf(question, sizeof(question),
B_TRANSLATE("What do you want to do "
"with the thread \"%s\"?"), thinfo.name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Debug this thread!"),
B_TRANSLATE("Kill this thread!"), B_WIDTH_AS_USUAL,
B_STOP_ALERT);
#define KILL 2
#else
snprintf(question, sizeof(question),
B_TRANSLATE("Are you sure you want "
"to kill the thread \"%s\"?"), thinfo.name);
alert = new BAlert(B_TRANSLATE("Please confirm"), question,
B_TRANSLATE("Cancel"), B_TRANSLATE("Kill this thread!"),
NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
#define KILL 1
#endif
alert->SetShortcut(0, B_ESCAPE);
int r = alert->Go();
if (r == KILL)
kill_thread(thread);
#if DEBUG_THREADS
else if (r == 1) {
Tdebug_thead_param* param = new Tdebug_thead_param;
param->thread = thread;
if (thinfo.state == B_THREAD_WAITING)
param->sem = thinfo.sem;
else
param->sem = -1;
param->totalTime = thinfo.user_time+thinfo.kernel_time;
resume_thread(spawn_thread(thread_debug_thread,
B_TRANSLATE("Debug thread"), B_NORMAL_PRIORITY, param));
}
#endif
} else {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This thread is already gone"B_UTF8_ELLIPSIS),
B_TRANSLATE("Ok!"), NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
alert->Go();
}
}
break;
case 'PrTh':
if (message->FindInt32("thread", &thread) == B_OK) {
long new_priority;
if (message->FindInt32("priority", &new_priority) == B_OK)
set_thread_priority(thread, new_priority);
}
break;
case 'Trac':
launch(kTrackerSig, "/boot/system/Tracker");
break;
case 'Dbar':
launch(kDeskbarSig, "/boot/system/Deskbar");
break;
case 'Term':
launch(kTerminalSig, "/boot/system/apps/Terminal");
break;
case 'AlDb':
{
if (!be_roster->IsRunning(kDeskbarSig))
launch(kDeskbarSig, "/boot/system/Deskbar");
BDeskbar deskbar;
if (gInDeskbar || deskbar.HasItem (kDeskbarItemName))
deskbar.RemoveItem (kDeskbarItemName);
else
move_to_deskbar(deskbar);
break;
}
case 'CPU ':
{
int32 cpu;
if (message->FindInt32 ("cpu", &cpu) == B_OK) {
bool last = true;
for (int p = 0; p < gCPUcount; p++) {
if (p != cpu && _kern_cpu_enabled(p)) {
last = false;
break;
}
}
if (last) {
alert = new BAlert(B_TRANSLATE("Info"),
B_TRANSLATE("This is the last active processor...\n"
"You can't turn it off!"),
B_TRANSLATE("That's no Fun!"), NULL, NULL,
B_WIDTH_AS_USUAL, B_WARNING_ALERT);
alert->SetShortcut(0, B_ESCAPE);
alert->Go();
} else
_kern_set_cpu_enabled(cpu, !_kern_cpu_enabled(cpu));
}
break;
}
case B_ABOUT_REQUESTED:
AboutRequested();
break;
default:
BView::MessageReceived(message);
}
}