#include "TeamsWindow.h"
#include <new>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <Application.h>
#include <Button.h>
#include <ControlLook.h>
#include <File.h>
#include <FilePanel.h>
#include <FindDirectory.h>
#include <LayoutBuilder.h>
#include <ListView.h>
#include <Menu.h>
#include <MenuField.h>
#include <Path.h>
#include <Screen.h>
#include <ScrollView.h>
#include <AutoDeleter.h>
#include <AutoLocker.h>
#include "AppMessageCodes.h"
#include "SettingsManager.h"
#include "TargetHostInterface.h"
#include "TargetHostInterfaceRoster.h"
#include "TeamsListView.h"
enum {
MSG_TEAM_SELECTION_CHANGED = 'tesc',
MSG_CHOSE_CORE_FILE = 'chcf',
MSG_SWITCH_TARGET_CONNECTION = 'stco'
};
TeamsWindow::TeamsWindow(SettingsManager* settingsManager)
:
BWindow(BRect(100, 100, 500, 500), "Teams", B_DOCUMENT_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS),
fTargetHostInterface(NULL),
fTeamsListView(NULL),
fAttachTeamButton(NULL),
fCreateTeamButton(NULL),
fLoadCoreButton(NULL),
fConnectionField(NULL),
fCoreSelectionPanel(NULL),
fSettingsManager(settingsManager),
fListeners()
{
team_info info;
get_team_info(B_CURRENT_TEAM, &info);
fCurrentTeam = info.team;
}
TeamsWindow::~TeamsWindow()
{
}
TeamsWindow*
TeamsWindow::Create(SettingsManager* settingsManager)
{
TeamsWindow* self = new TeamsWindow(settingsManager);
try {
self->_Init();
} catch (...) {
delete self;
throw;
}
return self;
}
void
TeamsWindow::Zoom(BPoint, float, float)
{
BSize preferredSize = fTeamsListView->PreferredSize();
ResizeBy(preferredSize.Width() - Bounds().Width(),
0.0);
BScreen screen;
float offset = screen.Frame().right - Frame().right;
if (offset < 0)
MoveBy(offset - 5.0, 0.0);
}
void
TeamsWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case MSG_DEBUG_THIS_TEAM:
{
TeamRow* row = dynamic_cast<TeamRow*>(
fTeamsListView->CurrentSelection());
if (row != NULL) {
BMessage message(MSG_DEBUG_THIS_TEAM);
message.AddInt32("team", row->TeamID());
message.AddPointer("interface", fTargetHostInterface);
be_app_messenger.SendMessage(&message);
}
break;
}
case MSG_TEAM_SELECTION_CHANGED:
{
TeamRow* row = dynamic_cast<TeamRow*>(
fTeamsListView->CurrentSelection());
bool enabled = false;
if (row != NULL) {
team_id id = row->TeamID();
if (id != fCurrentTeam && id != B_SYSTEM_TEAM)
enabled = true;
}
fAttachTeamButton->SetEnabled(enabled);
break;
}
case MSG_SHOW_START_TEAM_WINDOW:
{
BMessage startMessage(*message);
startMessage.AddPointer("interface", fTargetHostInterface);
be_app_messenger.SendMessage(&startMessage);
break;
}
case MSG_CHOSE_CORE_FILE:
case B_CANCEL:
{
delete fCoreSelectionPanel;
fCoreSelectionPanel = NULL;
if (message->what == B_CANCEL)
break;
entry_ref ref;
if (message->FindRef("refs", &ref) != B_OK)
break;
BMessage coreMessage(MSG_LOAD_CORE_TEAM);
coreMessage.AddPointer("interface", fTargetHostInterface);
coreMessage.AddRef("core", &ref);
be_app_messenger.SendMessage(&coreMessage);
break;
}
case MSG_LOAD_CORE_TEAM:
{
try {
BMessenger messenger(this);
fCoreSelectionPanel = new BFilePanel(B_OPEN_PANEL, &messenger,
NULL, 0, false, new BMessage(MSG_CHOSE_CORE_FILE));
fCoreSelectionPanel->Show();
} catch (...) {
delete fCoreSelectionPanel;
fCoreSelectionPanel = NULL;
}
break;
}
case MSG_SWITCH_TARGET_CONNECTION:
{
TargetHostInterface* interface;
if (message->FindPointer("interface", reinterpret_cast<void**>(
&interface)) != B_OK) {
break;
}
if (interface == fTargetHostInterface)
break;
fTargetHostInterface = interface;
_NotifySelectedInterfaceChanged(interface);
fLoadCoreButton->SetEnabled(fTargetHostInterface->IsLocal());
break;
}
default:
BWindow::MessageReceived(message);
break;
}
}
bool
TeamsWindow::QuitRequested()
{
_SaveSettings();
be_app_messenger.SendMessage(MSG_TEAMS_WINDOW_CLOSED);
return true;
}
void
TeamsWindow::AddListener(Listener* listener)
{
AutoLocker<TeamsWindow> locker(this);
fListeners.Add(listener);
}
void
TeamsWindow::RemoveListener(Listener* listener)
{
AutoLocker<TeamsWindow> locker(this);
fListeners.Remove(listener);
}
void
TeamsWindow::_Init()
{
BMessage settings;
_LoadSettings(settings);
BRect frame;
if (settings.FindRect("teams window frame", &frame) == B_OK) {
MoveTo(frame.LeftTop());
ResizeTo(frame.Width(), frame.Height());
}
BMenu* connectionMenu = new BMenu("Connection");
ObjectDeleter<BMenu> menuDeleter(connectionMenu);
connectionMenu->SetLabelFromMarked(true);
TargetHostInterfaceRoster* roster = TargetHostInterfaceRoster::Default();
for (int32 i = 0; i < roster->CountActiveInterfaces(); i++) {
TargetHostInterface* interface = roster->ActiveInterfaceAt(i);
BMenuItem* item = new BMenuItem(interface->GetTargetHost()->Name(),
new BMessage(MSG_SWITCH_TARGET_CONNECTION));
if (item->Message()->AddPointer("interface", interface) != B_OK) {
delete item;
throw std::bad_alloc();
}
if (interface->IsLocal()) {
item->SetMarked(true);
fTargetHostInterface = interface;
}
connectionMenu->AddItem(item);
}
BGroupLayout* connectionLayout = NULL;
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_DEFAULT_SPACING)
.GetLayout(&connectionLayout)
.Add(fConnectionField = new BMenuField("Connected to:",
connectionMenu))
.AddGlue()
.Add(fCreateConnectionButton = new BButton("Create new connection"
B_UTF8_ELLIPSIS, new BMessage(
MSG_SHOW_CONNECTION_CONFIG_WINDOW)))
.End()
.Add(fTeamsListView = new TeamsListView("TeamsList"))
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_ITEM_SPACING, 0,
be_control_look->GetScrollBarWidth(B_VERTICAL),
be_control_look->GetScrollBarWidth(B_HORIZONTAL))
.Add(fAttachTeamButton = new BButton("Attach", new BMessage(
MSG_DEBUG_THIS_TEAM)))
.AddGlue()
.Add(fCreateTeamButton = new BButton("Start new team"
B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_START_TEAM_WINDOW)))
.Add(fLoadCoreButton = new BButton("Load core" B_UTF8_ELLIPSIS,
new BMessage(MSG_LOAD_CORE_TEAM)))
.End()
.End();
connectionLayout->SetVisible(false);
menuDeleter.Detach();
AddListener(fTeamsListView);
connectionMenu->SetTargetForItems(this);
fTeamsListView->SetInvocationMessage(new BMessage(MSG_DEBUG_THIS_TEAM));
fTeamsListView->SetSelectionMessage(new BMessage(
MSG_TEAM_SELECTION_CHANGED));
fAttachTeamButton->SetEnabled(false);
fCreateTeamButton->SetTarget(this);
fLoadCoreButton->SetTarget(this);
fCreateConnectionButton->SetTarget(be_app);
_NotifySelectedInterfaceChanged(fTargetHostInterface);
}
status_t
TeamsWindow::_OpenSettings(BFile& file, uint32 mode)
{
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
return B_ERROR;
path.Append("Debugger settings");
return file.SetTo(path.Path(), mode);
}
status_t
TeamsWindow::_LoadSettings(BMessage& settings)
{
BFile file;
status_t status = _OpenSettings(file, B_READ_ONLY);
if (status < B_OK)
return status;
return settings.Unflatten(&file);
}
status_t
TeamsWindow::_SaveSettings()
{
BFile file;
status_t status = _OpenSettings(file,
B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
if (status < B_OK)
return status;
BMessage settings('hdbg');
status = settings.AddRect("teams window frame", Frame());
if (status != B_OK)
return status;
if (status == B_OK)
status = settings.Flatten(&file);
return status;
}
void
TeamsWindow::_NotifySelectedInterfaceChanged(TargetHostInterface* interface)
{
for (ListenerList::Iterator it = fListeners.GetIterator();
Listener* listener = it.Next();) {
listener->SelectedInterfaceChanged(interface);
}
}
TeamsWindow::Listener::~Listener()
{
}
