i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Patch by Pieter Panman:

Browse Source 
* Rewrote Devices application. -> Thanks a bunch!! Nice work!
* Put Devices onto the image.

Changes by myself:
* Merge some code from the old "preflet" which the new app still relied on.
* Fixed some coding style issues. I didn't review all of the code yet, though.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33640 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus
2009-10-18 17:59:07 +00:00
parent cb42b864b9
commit 55b42c2b4d
28 changed files with 1599 additions and 1939 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build/jam/HaikuImage
+5 -5
View File
@@ -62,9 +62,9 @@ SYSTEM_BIN = "[" addattr alert arp base64 basename bash bc beep bootman bzip2
zdiff zforce zgrep zip zipcloak <bin>zipgrep zipnote zipsplit zmore znew zdiff zforce zgrep zip zipcloak <bin>zipgrep zipnote zipsplit zmore znew
; ;
SYSTEM_APPS = AboutSystem ActivityMonitor CharacterMap CodyCam DeskCalc DiskProbe SYSTEM_APPS = AboutSystem ActivityMonitor CharacterMap CodyCam DeskCalc Devices
DiskUsage DriveSetup CDPlayer Expander Icon-O-Matic Installer LaunchBox DiskProbe DiskUsage DriveSetup CDPlayer Expander Icon-O-Matic Installer
Magnify Mail MediaConverter MediaPlayer MidiPlayer NetworkStatus LaunchBox Magnify Mail MediaConverter MediaPlayer MidiPlayer NetworkStatus
PackageInstaller People PoorMan PowerStatus ProcessController Screenshot PackageInstaller People PoorMan PowerStatus ProcessController Screenshot
ShowImage SoundRecorder StyledEdit Terminal TextSearch TV Workspaces ShowImage SoundRecorder StyledEdit Terminal TextSearch TV Workspaces
; ;
@@ -304,8 +304,8 @@ AddSymlinkToHaikuImage home config settings Mail : ../../../mail/in : mailbox ;
# Deskbar Application links # Deskbar Application links
AddDirectoryToHaikuImage home config be Applications ; AddDirectoryToHaikuImage home config be Applications ;
DESKBAR_APPLICATIONS = ActivityMonitor CharacterMap CodyCam CDPlayer DeskCalc DESKBAR_APPLICATIONS = ActivityMonitor CharacterMap CodyCam CDPlayer DeskCalc
DiskProbe DriveSetup DiskUsage Expander Icon-O-Matic Installer Magnify Devices DiskProbe DriveSetup DiskUsage Expander Icon-O-Matic Installer
Mail MediaConverter MediaPlayer MidiPlayer People PoorMan Screenshot Magnify Mail MediaConverter MediaPlayer MidiPlayer People PoorMan Screenshot
SoundRecorder StyledEdit Terminal TV SoundRecorder StyledEdit Terminal TV
; ;
local linkTarget ; local linkTarget ;
src/apps/devices/ConfigurationWindow.cpp
-633
View File
@@ -1,633 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2003-2004, Haiku
//
// This software is part of the Haiku distribution and is covered
// by the Haiku license.
//
//
// File: ConfigurationWindow.cpp
// Author: Jérôme Duval
// Description: Devices Preferences
// Created : April 22, 2004
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// Includes ------------------------------------------------------------------------------------------ //
#include <Application.h>
#include <Box.h>
#include <Button.h>
#include <ByteOrder.h>
#include <MenuItem.h>
#include <MenuField.h>
#include <Path.h>
#include <PopUpMenu.h>
#include <Screen.h>
#include <stdio.h>
#include <ScrollView.h>
#include <String.h>
#include <StringView.h>
#include <TabView.h>
#include <TextView.h>
#include <Window.h>
#include <View.h>
#include "DevicesWindows.h"
#include "pcihdr.h"
#define CONFIGURATION_CHANGED 'cfch'
#define IRQ_CHANGED 'irch'
#define DMA_CHANGED 'irch'
class RangeConfItem : public BListItem
{
public:
RangeConfItem(uint32 lowAddress, uint32 highAddress);
~RangeConfItem();
virtual void DrawItem(BView *, BRect, bool = false);
static int Compare(const void *firstArg, const void *secondArg);
private:
uint32 fLowAddress, fHighAddress;
};
RangeConfItem::RangeConfItem(uint32 lowAddress, uint32 highAddress)
: BListItem(),
fLowAddress(lowAddress),
fHighAddress(highAddress)
{
}
RangeConfItem::~RangeConfItem()
{
}
/***********************************************************
* DrawItem
***********************************************************/
void
RangeConfItem::DrawItem(BView *owner, BRect itemRect, bool complete)
{
rgb_color kBlack = { 0,0,0,0 };
rgb_color kHighlight = { 156,154,156,0 };
if (IsSelected() || complete) {
rgb_color color;
if (IsSelected())
color = kHighlight;
else
color = owner->ViewColor();
owner->SetHighColor(color);
owner->SetLowColor(color);
owner->FillRect(itemRect);
owner->SetHighColor(kBlack);
} else {
owner->SetLowColor(owner->ViewColor());
}
BFont font = be_plain_font;
font_height finfo;
font.GetHeight(&finfo);
BPoint point = BPoint(itemRect.left + 4, itemRect.bottom - finfo.descent + 1);
owner->SetFont(be_plain_font);
owner->SetHighColor(kBlack);
owner->MovePenTo(point);
char string[20];
if (fLowAddress >= 0) {
sprintf(string, "0x%04lx", fLowAddress);
owner->DrawString(string);
}
point += BPoint(75, 0);
owner->MovePenTo(point);
owner->StrokeLine(point + BPoint(0,-3), point + BPoint(4,-3));
point += BPoint(15, 0);
owner->MovePenTo(point);
owner->SetFont(be_plain_font);
if (fHighAddress >= 0) {
sprintf(string, "0x%04lx", fHighAddress);
owner->DrawString(string);
}
}
int
RangeConfItem::Compare(const void *firstArg, const void *secondArg)
{
const RangeConfItem *item1 = *static_cast<const RangeConfItem * const *>(firstArg);
const RangeConfItem *item2 = *static_cast<const RangeConfItem * const *>(secondArg);
if (item1->fLowAddress < item2->fLowAddress) {
return -1;
} else if (item1->fLowAddress > item2->fLowAddress) {
return 1;
} else
return 0;
}
// -------------------------------------------------------------------------------------------------- //
// ConfigurationWindow - Constructor
ConfigurationWindow::ConfigurationWindow(BRect frame, DeviceItem *item)
: BWindow (frame, item->GetInfo()->GetCardName(), B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL ,
B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE|B_NOT_RESIZABLE),
fItem(item)
{
CenterOnScreen();
fItem->SetWindow(this);
InitWindow();
Show();
}
// -------------------------------------------------------------------------------------------------- //
// ConfigurationWindow - Destructor
ConfigurationWindow::~ConfigurationWindow()
{
}
// -------------------------------------------------------------------------------------------------- //
// ConfigurationWindow::InitWindow -- Initialization Commands here
void
ConfigurationWindow::InitWindow(void)
{
DevicesInfo *devicesInfo = fItem->GetInfo();
BRect bRect = Bounds();
BBox *background = new BBox(bRect, "background", B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW, B_NO_BORDER);
AddChild(background);
BRect rtab = Bounds();
BRect rlist = Bounds();
rtab.top += 10;
rlist.top += 11;
rlist.left += 13;
rlist.right -= 13;
rlist.bottom -= 44;
// Create the TabView and Tabs
BTabView *tabView = new BTabView(rtab,"resource_usage_tabview");
tabView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
rtab = tabView->Bounds();
rtab.InsetBy(5,5);
// Create the Views
BBox *resources = new BBox(rlist, "resources",
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
BMenuItem *menuItem;
fConfigurationMenu = new BPopUpMenu("<empty>");
fConfigurationMenu->AddItem(menuItem = new BMenuItem("Current Configuration",
new BMessage(CONFIGURATION_CHANGED)));
menuItem->SetMarked(true);
fConfigurationMenu->AddItem(menuItem = new BMenuItem("Default Configuration",
new BMessage(CONFIGURATION_CHANGED)));
menuItem->SetEnabled(false);
fConfigurationMenu->AddItem(menuItem = new BMenuItem("Disable Device",
new BMessage(CONFIGURATION_CHANGED)));
menuItem->SetEnabled(false);
fConfigurationMenu->AddSeparatorItem();
fConfigurationMenu->AddItem(menuItem = new BMenuItem("Possible Configuration 0",
new BMessage(CONFIGURATION_CHANGED)));
BMenuField *configurationMenuField = new BMenuField(BRect(0,0,174 + (be_plain_font->Size() - 12) * 10,18), "configurationMenuField",
NULL, fConfigurationMenu, true);
resources->SetLabel(configurationMenuField);
fIRQMenu[0] = new BPopUpMenu("<empty>");
fIRQMenu[1] = new BPopUpMenu("<empty>");
fIRQMenu[2] = new BPopUpMenu("<empty>");
fDMAMenu[0] = new BPopUpMenu("<empty>");
fDMAMenu[1] = new BPopUpMenu("<empty>");
fDMAMenu[2] = new BPopUpMenu("<empty>");
BRect fieldRect;
fieldRect.top = 25;
fieldRect.left = 22;
fieldRect.right = fieldRect.left + 72;
fieldRect.bottom = fieldRect.top + 18;
BMenuField *field;
fIRQField[0] = field = new BMenuField(fieldRect, "IRQ1Field", "IRQs", fIRQMenu[0], true);
field->SetEnabled(false);
field->SetDivider(33);
resources->AddChild(field);
fieldRect.left = 25;
fieldRect.OffsetBy(71, 0);
fIRQField[1] = field = new BMenuField(fieldRect, "IRQ2Field", " and", fIRQMenu[1], true);
field->SetEnabled(false);
field->SetDivider(30);
resources->AddChild(field);
fieldRect.OffsetBy(71, 0);
fIRQField[2] = field = new BMenuField(fieldRect, "IRQ3Field", " and", fIRQMenu[2], true);
field->SetEnabled(false);
field->SetDivider(30);
resources->AddChild(field);
fieldRect.OffsetBy(-142, 23);
fieldRect.left = 14;
fDMAField[0] = field = new BMenuField(fieldRect, "DMA1Field", "DMAs", fDMAMenu[0], true);
field->SetEnabled(false);
field->SetDivider(41);
resources->AddChild(field);
fieldRect.left = 25;
fieldRect.OffsetBy(71, 0);
fDMAField[1] = field = new BMenuField(fieldRect, "DMA2Field", " and", fDMAMenu[1], true);
field->SetEnabled(false);
field->SetDivider(30);
resources->AddChild(field);
fieldRect.OffsetBy(71, 0);
fDMAField[2] = field = new BMenuField(fieldRect, "DMA3Field", " and", fDMAMenu[2], true);
field->SetEnabled(false);
field->SetDivider(30);
resources->AddChild(field);
fIRQMenu[0]->Superitem()->SetLabel("");
fIRQMenu[1]->Superitem()->SetLabel("");
fIRQMenu[2]->Superitem()->SetLabel("");
fDMAMenu[0]->Superitem()->SetLabel("");
fDMAMenu[1]->Superitem()->SetLabel("");
fDMAMenu[2]->Superitem()->SetLabel("");
BRect boxRect = resources->Bounds();
boxRect.top = 74;
boxRect.left += 13;
boxRect.right -= 11;
boxRect.bottom = boxRect.top + 141;
BBox *ioPortBox = new BBox(boxRect, "ioPort",
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
ioPortBox->SetLabel(new BStringView(BRect(0,0,150,15), "ioPortLabel", " IO Port Ranges "));
resources->AddChild(ioPortBox);
boxRect.OffsetBy(0, 149);
boxRect.bottom = boxRect.top + 140;
BBox *memoryBox = new BBox(boxRect, "memory",
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW);
memoryBox->SetLabel(new BStringView(BRect(0,0,150,15), "memoryLabel", " Memory Ranges "));
resources->AddChild(memoryBox);
ioListView = new BListView(BRect(14,22,164,127), "ioListView");
memoryListView = new BListView(BRect(14,22,164,127), "memoryListView");
BScrollView *ioScrollView = new BScrollView("ioScrollView", ioListView, B_FOLLOW_LEFT|B_FOLLOW_TOP,
0, false, true, B_FANCY_BORDER);
ioPortBox->AddChild(ioScrollView);
BScrollView *memoryScrollView = new BScrollView("memoryScrollView", memoryListView, B_FOLLOW_LEFT|B_FOLLOW_TOP,
0, false, true, B_FANCY_BORDER);
memoryBox->AddChild(memoryScrollView);
struct device_configuration *current = devicesInfo->GetCurrent();
resource_descriptor r;
{
int32 k = 0;
int32 num = count_resource_descriptors_of_type(current, B_IRQ_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_IRQ_RESOURCE,
&r, sizeof(resource_descriptor));
uint32 mask = r.d.m.mask;
int16 j = 0;
if (!mask)
continue;
for (;mask;mask>>=1,j++)
if (mask & 1) {
char value[50];
sprintf(value, "%d", j);
BMenuItem *item = new BMenuItem(value, new BMessage(IRQ_CHANGED));
fIRQMenu[k]->AddItem(item);
item->SetMarked(true);
fIRQField[k]->SetEnabled(true);
}
}
}
{
int32 k = 0;
int32 num = count_resource_descriptors_of_type(current, B_DMA_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_DMA_RESOURCE,
&r, sizeof(resource_descriptor));
uint32 mask = r.d.m.mask;
int16 j = 0;
if (!mask)
continue;
for (;mask;mask>>=1,j++)
if (mask & 1) {
char value[50];
sprintf(value, "%d", j);
BMenuItem *item = new BMenuItem(value, new BMessage(DMA_CHANGED));
fDMAMenu[k]->AddItem(item);
item->SetMarked(true);
fDMAField[k++]->SetEnabled(true);
}
}
}
{
int32 num = count_resource_descriptors_of_type(current, B_IO_PORT_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_IO_PORT_RESOURCE,
&r, sizeof(resource_descriptor));
ioListView->AddItem(new RangeConfItem(r.d.r.minbase,
r.d.r.minbase + r.d.r.len - 1));
}
ioListView->SortItems(&RangeConfItem::Compare);
}
{
int32 num = count_resource_descriptors_of_type(current, B_MEMORY_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_MEMORY_RESOURCE,
&r, sizeof(resource_descriptor));
memoryListView->AddItem(new RangeConfItem(r.d.r.minbase,
r.d.r.minbase + r.d.r.len - 1));
}
memoryListView->SortItems(&RangeConfItem::Compare);
}
BBox *info = new BBox(rlist, "info",
B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW, B_NO_BORDER);
bool isISAPnP = false;
BString compatibleIDString;
if (devicesInfo->GetInfo()->bus == B_ISA_BUS) {
uint32 id = devicesInfo->GetInfo()->id[0];
if ((id >> 24 == 'P')
&& (((id >> 16) & 0xff) == 'n')
&& (((id >> 8) & 0xff) == 'P')) {
isISAPnP = true;
char string[255];
sprintf(string, "Compatible ID #%ld:",
devicesInfo->GetInfo()->id[3]);
compatibleIDString = string;
}
}
BRect labelRect(1, 10, 132, 30);
BStringView *label = new BStringView(labelRect, "Card Name", "Card Name:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Device Name", "Device Name:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Logical Device Name", "Logical Device Name:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Bus Type", "Bus Type:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Device Type", "Device Type:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 36);
label = new BStringView(labelRect, "Vendor", "Vendor:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Card ID", "Card ID:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
if (isISAPnP) {
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Logical Device ID", "Logical Device ID:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Compatible ID#", compatibleIDString.String());
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
}
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Current State", "Current State:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Resource Conflicts", "Resource Conflicts:");
label->SetAlignment(B_ALIGN_RIGHT);
info->AddChild(label);
BString cardName = "<Unknown>";
BString logicalDeviceName = "<Unknown>";
BString bus;
switch (devicesInfo->GetInfo()->bus) {
case B_ISA_BUS: bus = "ISA device"; break;
case B_PCI_BUS: bus = "PCI device"; break;
case B_PCMCIA_BUS: bus = "PCMCIA device"; break;
default: bus = "<Unknown>"; break;
}
BString deviceType1, deviceType2;
deviceType1 += devicesInfo->GetBaseString();
deviceType1 += " (";
deviceType1 += devicesInfo->GetSubTypeString();
deviceType1 += ")";
char typeString[255];
sprintf(typeString, "Base: %x Subtype: %x Interface: %x",
devicesInfo->GetInfo()->devtype.base,
devicesInfo->GetInfo()->devtype.subtype,
devicesInfo->GetInfo()->devtype.interface);
deviceType2 = typeString;
BString vendor;
BString vendorString = "<Unknown>";
BString cardID = "";
BString resourceConflicts = "None";
BString logicalString;
switch (devicesInfo->GetInfo()->bus) {
case B_ISA_BUS:
{
char string[255];
if (isISAPnP) {
uint32 id = devicesInfo->GetInfo()->id[1];
sprintf(string, "%c%c%c Product: %x%x%x Revision: %d",
((uint8)(id >> 2) & 0x1f) + 'A' - 1,
((uint8)(id & 0x3) << 3) + ((uint8)(id >> 13) & 0x7) + 'A' - 1,
(uint8)(id >> 8) & 0x1f + 'A' - 1,
(uint8)(id >> 20) & 0xf,
(uint8)(id >> 16) & 0xf,
(uint8)(id >> 28) & 0xf,
(uint8)((id >> 24) & 0xf));
vendor = string;
sprintf(string, "%08lx", devicesInfo->GetInfo()->id[2]);
cardID = string;
id = devicesInfo->GetInfo()->id[3];
sprintf(string, "%c%c%c Product: %x%x%x Revision: %d",
((uint8)(id >> 2) & 0x1f) + 'A' - 1,
((uint8)(id & 0x3) << 3) + ((uint8)(id >> 13) & 0x7) + 'A' - 1,
(uint8)(id >> 8) & 0x1f + 'A' - 1,
(uint8)(id >> 20) & 0xf,
(uint8)(id >> 16) & 0xf,
(uint8)(id >> 28) & 0xf,
(uint8)((id >> 24) & 0xf));
logicalString = string;
cardName = devicesInfo->GetCardName();
} else {
uint32 id = devicesInfo->GetInfo()->id[2];
sprintf(string, "%c%c%c Product: %x%x Revision: %d",
((uint8)(id >> 2) & 0x1f) + 'A' - 1,
((uint8)(id & 0x3) << 3) + ((uint8)(id >> 13) & 0x7) + 'A' - 1,
(uint8)(id >> 8) & 0x1f + 'A' - 1,
(uint8)(id >> 16) & 0xf,
(uint8)(id >> 20) & 0xf,
(uint8)((id >> 24) & 0xff));
vendor = string;
cardID = "0";
}
}
break;
case B_PCI_BUS:
{
for (uint32 i=0; i<PCI_VENTABLE_LEN; i++)
if (PciVenTable[i].VenId == devicesInfo->GetInfo()->id[0] & 0xffff) {
vendorString = PciVenTable[i].VenFull;
break;
}
char string[255];
sprintf(string, "%s (0x%04lx)", vendorString.String(), devicesInfo->GetInfo()->id[0] & 0xffff);
vendor = string;
sprintf(string, "%04lx", devicesInfo->GetInfo()->id[1] & 0xffff);
cardID = string;
for (uint32 i = 0; i < PCI_DEVTABLE_LEN; i++) {
if (PciDevTable[i].VenId == devicesInfo->GetInfo()->id[0] & 0xffff &&
PciDevTable[i].DevId == devicesInfo->GetInfo()->id[1] & 0xffff) {
cardName = PciDevTable[i].ChipDesc;
break;
}
}
}
break;
case B_PCMCIA_BUS: vendor = "XX"; break;
default: vendor = "<Unknown>"; break;
}
BString state = "Enabled";
if (!(devicesInfo->GetInfo()->flags & B_DEVICE_INFO_ENABLED))
switch (devicesInfo->GetInfo()->config_status) {
case B_DEV_RESOURCE_CONFLICT: state = "Disabled by System"; break;
case B_DEV_DISABLED_BY_USER: state = "Disabled by User"; break;
default: state = "Disabled for Unknown Reason"; break;
}
labelRect = BRect(137, 10, 400, 30);
label = new BStringView(labelRect, "Card Name", cardName.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Device Name", devicesInfo->GetDeviceName());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Logical Device Name", logicalDeviceName.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Bus Type", bus.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Device Type", deviceType1.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Device Type", deviceType2.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Vendor", vendor.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Card ID", cardID.String());
info->AddChild(label);
if (isISAPnP) {
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Logical Device ID", logicalString.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Compatible ID", logicalString.String());
info->AddChild(label);
}
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Current State", state.String());
info->AddChild(label);
labelRect.OffsetBy(0, 18);
label = new BStringView(labelRect, "Resource Conflicts", resourceConflicts.String());
info->AddChild(label);
BTab *tab = new BTab();
tabView->AddTab(resources, tab);
tab->SetLabel("Resources");
tab = new BTab();
tabView->AddTab(info, tab);
tab->SetLabel("Info");
background->AddChild(tabView);
ioListView->Select(0);
memoryListView->Select(0);
}
// -------------------------------------------------------------------------------------------------- //
// ConfigurationWindow::MessageReceived -- receives messages
void
ConfigurationWindow::MessageReceived (BMessage *message)
{
switch(message->what)
{
default:
BWindow::MessageReceived(message);
break;
}
}
// -------------------------------------------------------------------------------------------------- //
// ConfigurationWindow::QuitRequested -- Post a message to the app to quit
bool
ConfigurationWindow::QuitRequested()
{
fItem->SetWindow(NULL);
return true;
}
// ---------------------------------------------------------------------------------------------------------- //
src/apps/devices/Device.cpp
+128
View File
@@ -0,0 +1,128 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Pieter Panman
*/
#include "Device.h"
#include <iostream>
// This list comes from the pciid list, except for the last one
const char* kCategoryString[] = {
"Unclassified device", // 0x00
"Mass storage controller", // 0x01
"Network controller", // 0x02
"Display controller", // 0x03
"Multimedia controller", // 0x04
"Memory controller", // 0x05
"Bridge", // 0x06
"Communication controller", // 0x07
"Generic system peripheral", // 0x08
"Input device controller", // 0x09
"Docking station", // 0x0a
"Processor", // 0x0b
"Serial bus controller", // 0x0c
"Wireless controller", // 0x0d
"Intelligent controller", // 0x0e
"Satellite communications controller", // 0x0f
"Encryption controller", // 0x10
"Signal processing controller", // 0x11
"Computer" // 0x12 (added later)
};
Device::Device(Device* physicalParent, BusType busType, Category category,
const BString& name, const BString& manufacturer,
const BString& driverUsed, const BString& devPathsPublished)
:
BStringItem(name.String()),
fBusType(busType),
fCategory(category),
fPhysicalParent(physicalParent)
{
SetAttribute("Device name", name);
SetAttribute("Manufacturer", manufacturer);
SetAttribute("Driver used", driverUsed);
SetAttribute("Device paths", devPathsPublished);
}
Device::~Device()
{
}
void
Device::SetAttribute(const BString& name, const BString& value)
{
if (name == "Device name") {
SetText(value.String());
}
fAttributeMap[name] = value;
}
Attributes
Device::GetBasicAttributes()
{
Attributes attributes;
attributes.push_back(Attribute("Device name:", GetName()));
attributes.push_back(Attribute("Manufacturer:", GetManufacturer()));
return attributes;
}
Attributes
Device::GetBusAttributes()
{
Attributes attributes;
attributes.push_back(Attribute("None", ""));
return attributes;
}
Attributes
Device::GetAllAttributes()
{
Attributes attributes;
AttributeMapIterator iter;
for (iter = fAttributeMap.begin(); iter != fAttributeMap.end(); iter++) {
attributes.push_back(Attribute(iter->first, iter->second));
}
return attributes;
}
BString
Device::GetBasicStrings()
{
BString str;
str << "Device Name\t\t\t\t: " << GetName() << "\n";
str << "Manufacturer\t\t\t: " << GetManufacturer() << "\n";
str << "Driver used\t\t\t\t: " << GetDriverUsed() << "\n";
str << "Device paths\t: " << GetDevPathsPublished();
return str;
}
BString
Device::GetBusStrings()
{
return "None";
}
BString
Device::GetAllStrings()
{
BString str;
AttributeMapIterator iter;
for (iter = fAttributeMap.begin(); iter != fAttributeMap.end(); iter++) {
str << iter->first << " : " << iter->second << "\n";
}
return str;
}
src/apps/devices/Device.h
+109
View File
@@ -0,0 +1,109 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Pieter Panman
*/
#ifndef DEVICE_H
#define DEVICE_H
#include <map>
#include <vector>
#include <String.h>
#include <StringItem.h>
extern "C" {
#include "dm_wrapper.h"
}
typedef enum {
BUS_ISA = 1,
BUS_PCI,
BUS_SCSI,
BUS_NONE
} BusType;
struct Attribute {
Attribute(BString name, BString value)
{ fName = name; fValue = value; }
BString fName;
BString fValue;
};
typedef std::map<BString, BString>::const_iterator AttributeMapIterator;
typedef std::map<BString, BString> AttributeMap;
typedef std::pair<BString, BString> AttributePair;
typedef std::vector<Attribute> Attributes;
typedef enum {
CAT_NONE = 0,
CAT_BUS = 6,
CAT_COMPUTER = 0x12
} Category;
extern const char* kCategoryString[];
class Device : public BStringItem {
public:
Device(Device* physicalParent,
BusType busType=BUS_NONE,
Category category=CAT_NONE,
const BString& name = "unknown",
const BString& manufacturer = "unknown",
const BString& driverUsed = "unknown",
const BString& devPathsPublished = "unknown");
virtual ~Device();
virtual BString GetName()
{ return fAttributeMap["Device name"]; }
virtual BString GetManufacturer()
{ return fAttributeMap["Manufacturer"]; }
virtual BString GetDriverUsed()
{ return fAttributeMap["Driver used"]; }
virtual BString GetDevPathsPublished()
{ return fAttributeMap["Device paths"]; }
virtual Category GetCategory() const
{ return fCategory; }
virtual Device* GetPhysicalParent() const
{ return fPhysicalParent; }
virtual BusType GetBusType() const
{ return fBusType; }
virtual Attributes GetBasicAttributes();
virtual Attributes GetBusAttributes();
virtual Attributes GetAllAttributes();
virtual BString GetBasicStrings();
virtual BString GetBusStrings();
virtual BString GetAllStrings();
virtual BString GetBusTabName()
{ return "Bus Information"; }
virtual Attribute GetAttribute(const BString& name)
{ return Attribute(name.String(),
fAttributeMap[name]); }
virtual void SetAttribute(const BString& name,
const BString& value);
virtual void InitFromAttributes() { return; }
protected:
AttributeMap fAttributeMap;
BusType fBusType;
Category fCategory;
Device* fPhysicalParent;
};
#endif /* DEVICE_H */
src/apps/devices/DevicePCI.cpp
+127
View File
@@ -0,0 +1,127 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Pieter Panman
*/
#include <sstream>
#include "DevicePCI.h"
extern "C" {
#include "dm_wrapper.h"
#include "pcihdr.h"
#include "pci-utils.h"
}
DevicePCI::DevicePCI(Device* parent)
:
Device(parent),
fClassBaseId(0),
fClassSubId(0),
fClassApiId(0),
fVendorId(0),
fDeviceId(0),
fSubsystemVendorId(0),
fSubSystemId(0)
{
}
DevicePCI::~DevicePCI()
{
}
BString ToHex(uint16 num)
{
std::stringstream ss;
ss.flags(std::ios::hex | std::ios::showbase);
ss << num;
return BString(ss.str().c_str());
}
void
DevicePCI::InitFromAttributes()
{
// Process the attributes
fClassBaseId = atoi(fAttributeMap[B_DEVICE_TYPE].String());
fClassSubId = atoi(fAttributeMap[B_DEVICE_SUB_TYPE].String());
fClassApiId = atoi(fAttributeMap[B_DEVICE_INTERFACE].String());
fVendorId = atoi(fAttributeMap[B_DEVICE_VENDOR_ID].String());
fDeviceId = atoi(fAttributeMap[B_DEVICE_ID].String());
// Looks better in Hex, so rewrite
fAttributeMap[B_DEVICE_TYPE] = ToHex(fClassBaseId);
fAttributeMap[B_DEVICE_SUB_TYPE] = ToHex(fClassSubId);
fAttributeMap[B_DEVICE_INTERFACE] = ToHex(fClassApiId);
fAttributeMap[B_DEVICE_VENDOR_ID] = ToHex(fVendorId);
fAttributeMap[B_DEVICE_ID] = ToHex(fDeviceId);
// Fetch ClassInfo
char classInfo[64];
get_class_info(fClassBaseId, fClassSubId, fClassApiId, classInfo, sizeof(classInfo));
// Fetch ManufacturerName
BString ManufacturerName;
const char *venShort;
const char *venFull;
get_vendor_info(fVendorId, &venShort, &venFull);
if (!venShort && !venFull) {
ManufacturerName << "Unkown";
} else if (venShort && venFull) {
ManufacturerName << venFull << "(" << venShort << ")";
} else {
ManufacturerName << (venShort ? venShort : venFull);
}
// Fetch DeviceName
BString DeviceName;
const char *devShort;
const char *devFull;
get_device_info(fVendorId, fDeviceId, fSubsystemVendorId, fSubSystemId, &devShort, &devFull);
if (!devShort && !devFull) {
DeviceName << "Unknown";
} else if (devShort && devFull) {
DeviceName << devFull << "(" << devShort << ")";
} else {
DeviceName << (devShort ? devShort : devFull);
}
SetAttribute("Device name", DeviceName);
SetAttribute("Manufacturer", ManufacturerName);
SetAttribute("Driver used", "Not implemented");
SetAttribute("Device paths", "Not implemented");
SetAttribute("Class Info", classInfo);
fCategory = (Category)fClassBaseId;
BString outlineName;
outlineName << ManufacturerName << " " << DeviceName;
SetText(outlineName.String());
}
Attributes
DevicePCI::GetBusAttributes()
{
Attributes attributes;
attributes.push_back(GetAttribute(B_DEVICE_TYPE));
attributes.push_back(GetAttribute(B_DEVICE_SUB_TYPE));
attributes.push_back(GetAttribute(B_DEVICE_INTERFACE));
attributes.push_back(GetAttribute(B_DEVICE_VENDOR_ID));
attributes.push_back(GetAttribute(B_DEVICE_ID));
return attributes;
}
BString
DevicePCI::GetBusStrings()
{
BString str;
str << "Class Info:\t\t\t\t: " << fAttributeMap["Class Info"];
return str;
}
src/apps/devices/DevicePCI.h
+36
View File
@@ -0,0 +1,36 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Pieter Panman
*/
#ifndef DEVICEPCI_H
#define DEVICEPCI_H
#include "Device.h"
class DevicePCI : public Device {
public:
DevicePCI(Device* parent);
virtual ~DevicePCI();
virtual Attributes GetBusAttributes();
virtual BString GetBusStrings();
virtual void InitFromAttributes();
virtual BString GetBusTabName()
{ return "PCI Information"; }
private:
uint16 fClassBaseId;
uint16 fClassSubId;
uint16 fClassApiId;
uint16 fVendorId;
uint16 fDeviceId;
uint16 fSubsystemVendorId;
uint16 fSubSystemId;
};
#endif /* DEVICEPCI_H */
src/apps/devices/Devices.cpp
-67
View File
@@ -1,67 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2003-2004, Haiku
//
// This software is part of the Haiku distribution and is covered
// by the Haiku license.
//
//
// File: Devices.cpp
// Author: Sikosis, Jérôme Duval
// Description: Devices Preferences
// Created : March 04, 2003
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// Includes -------------------------------------------------------------------------------------------------- //
#include <Application.h>
#include "DevicesWindows.h"
#define APP_SIGNATURE "application/x-vnd.Haiku.Devices" // Application Signature and Title
class Devices : public BApplication
{
public:
Devices();
virtual void MessageReceived(BMessage *message);
private:
};
// ---------------------------------------------------------------------------------------------------------- //
// Devices -- constructor
Devices::Devices() : BApplication (APP_SIGNATURE)
{
BRect DevicesWindowRect(0,0,396,400);
new DevicesWindow(DevicesWindowRect);
}
// ---------------------------------------------------------------------------------------------------------- //
// Devices::MessageReceived -- handles incoming messages
void Devices::MessageReceived (BMessage *message)
{
switch(message->what)
{
default:
BApplication::MessageReceived(message); // pass it along ...
break;
}
}
// ---------------------------------------------------------------------------------------------------------- //
// Devices Main
int
main(void)
{
Devices theApp;
theApp.Run();
return 0;
}
// end ------------------------------------------------------------------------------------------------------ //
src/apps/devices/Devices.rdef
+3 -3
View File
@@ -1,5 +1,5 @@
resource app_signature "application/x-vnd.Haiku.Devices"; resource app_signature "application/x-vnd.Haiku-Devices";
resource app_version resource app_version
{ {
@@ -9,12 +9,12 @@ resource app_version
/* 0 = development 1 = alpha 2 = beta /* 0 = development 1 = alpha 2 = beta
3 = gamma 4 = golden master 5 = final */ 3 = gamma 4 = golden master 5 = final */
variety = 2, variety = 1,
internal = 0, internal = 0,
short_info = "Devices", short_info = "Devices",
long_info = "Devices ©2002-2009 Haiku" long_info = "Devices ©2009 Haiku"
}; };
resource app_flags B_SINGLE_LAUNCH; resource app_flags B_SINGLE_LAUNCH;
src/apps/devices/DevicesApplication.cpp
+119
View File
@@ -0,0 +1,119 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT license.
*
* Authors:
* Pieter Panman
*/
#include <Alert.h>
#include <Application.h>
#include <TextView.h>
#include "DevicesView.h"
class DevicesApplication : public BApplication {
public:
DevicesApplication();
virtual void AboutRequested();
static void ShowAbout();
};
class DevicesWindow : public BWindow {
public:
DevicesWindow();
virtual void MessageReceived(BMessage* message);
private:
DevicesView* fDevicesView;
};
DevicesApplication::DevicesApplication()
:
BApplication("application/x-vnd.Haiku-Devices")
{
DevicesWindow* window = new DevicesWindow();
window->CenterOnScreen();
window->Show();
}
void
DevicesApplication::AboutRequested()
{
ShowAbout();
}
void
DevicesApplication::ShowAbout()
{
BAlert* alert = new BAlert("about", "Devices\n"
"\twritten by Pieter Panman\n"
"\n"
"\tBased on listdev by Jérôme Duval\n"
"\tand the previous Devices preference\n"
"\tby Jérôme Duval and Sikosis\n"
"\tCopyright 2009, Haiku Inc.\n", "Ok");
BTextView* view = alert->TextView();
BFont font;
view->SetStylable(true);
view->GetFont(&font);
font.SetSize(18);
font.SetFace(B_BOLD_FACE);
view->SetFontAndColor(0, 7, &font);
alert->Go();
}
DevicesWindow::DevicesWindow()
:
BWindow(BRect(50, 50, 750, 550), "Devices", B_TITLED_WINDOW,
B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS
| B_QUIT_ON_WINDOW_CLOSE)
{
float minWidth;
float maxWidth;
float minHeight;
float maxHeight;
GetSizeLimits(&minWidth, &maxWidth, &minHeight, &maxHeight);
minWidth = 600;
minHeight = 300;
SetSizeLimits(minWidth, maxWidth, minHeight, maxHeight);
fDevicesView = new DevicesView(Bounds());
AddChild(fDevicesView);
}
void
DevicesWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgRefresh:
case kMsgReportCompatibility:
case kMsgGenerateSysInfo:
case kMsgSelectionChanged:
case kMsgOrderCategory:
case kMsgOrderConnection:
fDevicesView->MessageReceived(message);
break;
default:
BWindow::MessageReceived(message);
break;
}
}
int
main()
{
DevicesApplication app;
app.Run();
return 0;
}
src/apps/devices/DevicesInfo.cpp
-219
View File
@@ -1,219 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2004, Haiku
//
// This software is part of the Haiku distribution and is covered
// by the Haiku license.
//
//
// File: DevicesInfo.cpp
// Author: Jérôme Duval
// Description: Devices Preferences
// Created : April 15, 2004
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
#include <strings.h>
#include <GraphicsDefs.h>
#include <String.h>
#include <View.h>
#include "DevicesInfo.h"
#include <stdio.h>
#include "isapnpids.h"
const char *base_desc[] = {
"Legacy",
"Mass Storage Controller",
"Network Controller", // "NIC"
"Display Controller",
"Multimedia Device",
"Memory Controller",
"Bridge Device",
"Communication Device",
"Motherboard Device", // "Generic System Peripheral"
"Input Device",
"Docking Station",
"Processor", // "CPU"
"Serial Bus Controller"
};
struct subtype_descriptions {
uchar base, subtype;
char *name;
} subtype_desc[] = {
{ 0, 0, "non-VGA" },
{ 0, 0, "VGA" },
{ 1, 0, "SCSI Controller" },
{ 1, 1, "IDE Controller" }, // "IDE"
{ 1, 2, "Floppy Controller" }, // "Floppy"
{ 1, 3, "IPI" },
{ 1, 4, "RAID" },
{ 2, 0, "Ethernet" },
{ 2, 1, "Token Ring" },
{ 2, 2, "FDDI" },
{ 2, 3, "ATM" },
{ 3, 0, "VGA" }, // "VGA/8514"
{ 3, 1, "XGA" },
{ 4, 0, "Video" },
{ 4, 1, "Sound" }, // was "Audio"
{ 5, 0, "RAM" },
{ 5, 1, "Flash Memory" }, // "Flash"
{ 6, 0, "Host bridge" }, // "Host"
{ 6, 1, "ISA bridge" }, // "ISA"
{ 6, 2, "EISA" },
{ 6, 3, "MCA" },
{ 6, 4, "PCI-PCI bridge"}, // "PCI-PCI"
{ 6, 5, "PCMCIA" },
{ 6, 6, "NuBus" },
{ 6, 7, "CardBus bridge" }, // "CardBus"
{ 7, 0, "Serial Port" }, // "Serial"
{ 7, 1, "Parallel Port" }, // "Parallel"
{ 8, 0, "PIC" },
{ 8, 1, "DMA" },
{ 8, 2, "Timer" },
{ 8, 3, "RTC" },
{ 9, 0, "Keyboard" },
{ 9, 1, "Digitizer" },
{ 9, 2, "Mouse" },
{10, 0, "Generic" },
{11, 0, "386" },
{11, 1, "486" },
{11, 2, "Pentium" },
{11,16, "Alpha" },
{11,32, "PowerPC" },
{11,48, "Coprocessor" },
{12, 0, "FireWire" }, // was "IEEE 1394"
{12, 1, "ACCESS" },
{12, 2, "SSA" },
{12, 3, "USB" },
{12, 4, "Fibre Channel" },
{255,255, NULL }
};
DevicesInfo::DevicesInfo(struct device_info *info,
struct device_configuration *current,
struct possible_device_configurations *possible)
: fInfo(info),
fCurrent(current),
fPossible(possible)
{
struct subtype_descriptions *s = NULL;
if (info->devtype.subtype != 0x80) {
s = subtype_desc;
while (s->name) {
if ((info->devtype.base == s->base) && (info->devtype.subtype == s->subtype))
break;
s++;
}
}
fDeviceName = strdup((info->devtype.base < 13)
? ( (s && s->name) ? s->name : base_desc[info->devtype.base])
: "Unknown");
fCardName = fDeviceName;
if (fInfo->bus == B_ISA_BUS) {
uint32 id = fInfo->id[0];
if ((id >> 24 == 'P')
&& (((id >> 16) & 0xff) == 'n')
&& (((id >> 8) & 0xff) == 'P')) {
id = fInfo->id[3];
char string[255];
sprintf(string, "%c%c%c%x%x%x%x",
((uint8)(id >> 2) & 0x1f) + 'A' - 1,
((uint8)(id & 0x3) << 3) + ((uint8)(id >> 13) & 0x7) + 'A' - 1,
(uint8)(id >> 8) & 0x1f + 'A' - 1,
(uint8)(id >> 20) & 0xf,
(uint8)(id >> 16) & 0xf,
(uint8)(id >> 28) & 0xf,
(uint8)((id >> 24) & 0xf));
for (uint32 i=0; i<ISA_DEVTABLE_LEN; i++)
if (strcasecmp(isapnp_devids[i].id, string)==0) {
fCardName = isapnp_devids[i].devname;
}
}
}
fBaseString = strdup((info->devtype.base < 13) ? base_desc[info->devtype.base] : "Unknown");
fSubTypeString = strdup((s && s->name) ? s->name : "Unknown");
}
DevicesInfo::~DevicesInfo()
{
delete fInfo;
delete fCurrent;
delete fPossible;
delete fDeviceName;
delete fBaseString;
delete fSubTypeString;
}
DeviceItem::DeviceItem(DevicesInfo *info, const char* name)
: BListItem(),
fInfo(info),
fWindow(NULL)
{
fName = strdup(name);
}
DeviceItem::~DeviceItem()
{
delete fName;
}
/***********************************************************
* DrawItem
***********************************************************/
void
DeviceItem::DrawItem(BView *owner, BRect itemRect, bool complete)
{
rgb_color kBlack = { 0,0,0,0 };
rgb_color kHighlight = { 156,154,156,0 };
if (IsSelected() || complete) {
rgb_color color;
if (IsSelected())
color = kHighlight;
else
color = owner->ViewColor();
owner->SetHighColor(color);
owner->SetLowColor(color);
owner->FillRect(itemRect);
owner->SetHighColor(kBlack);
} else {
owner->SetLowColor(owner->ViewColor());
}
BFont font = be_plain_font;
font_height finfo;
font.GetHeight(&finfo);
BPoint point = BPoint(itemRect.left + 4, itemRect.bottom - finfo.descent + 1);
owner->SetHighColor(kBlack);
owner->SetFont(&font);
owner->MovePenTo(point);
owner->DrawString(fName);
if (fInfo) {
point += BPoint(222, 0);
BString string = "enabled";
if (!(fInfo->GetInfo()->flags & B_DEVICE_INFO_ENABLED))
switch (fInfo->GetInfo()->config_status) {
case B_DEV_RESOURCE_CONFLICT: string = "disabled by system"; break;
case B_DEV_DISABLED_BY_USER: string = "disabled by user"; break;
default: string = "disabled for unknown reason"; break;
}
owner->MovePenTo(point);
owner->DrawString(string.String());
}
}
src/apps/devices/DevicesInfo.h
-59
View File
@@ -1,59 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2004, Haiku
//
// This software is part of the Haiku distribution and is covered
// by the Haiku license.
//
//
// File: DevicesInfo.h
// Author: Jérôme Duval
// Description: Devices Preferences
// Created : April 15, 2004
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
#ifndef __DEVICESINFO_H__
#define __DEVICESINFO_H__
#include <drivers/config_manager.h>
#include <ListItem.h>
#include <Window.h>
class DevicesInfo
{
public:
DevicesInfo(struct device_info *info,
struct device_configuration *current,
struct possible_device_configurations *possible);
~DevicesInfo();
struct device_info * GetInfo() { return fInfo;}
char * GetDeviceName() const { return fDeviceName; }
char * GetCardName() const { return fCardName; }
char * GetBaseString() const { return fBaseString; }
char * GetSubTypeString() const { return fSubTypeString; }
struct device_configuration * GetCurrent() { return fCurrent;}
char * GetISAName() const;
private:
struct device_info *fInfo;
struct device_configuration *fCurrent;
struct possible_device_configurations *fPossible;
char* fDeviceName, *fCardName, *fBaseString, *fSubTypeString;
};
class DeviceItem : public BListItem
{
public:
DeviceItem(DevicesInfo *info, const char* name);
~DeviceItem();
DevicesInfo *GetInfo() { return fInfo; }
virtual void DrawItem(BView *, BRect, bool = false);
BWindow *GetWindow() { return fWindow; };
void SetWindow(BWindow *window) { fWindow = window; };
private:
DevicesInfo *fInfo;
char* fName;
BWindow *fWindow;
};
#endif
src/apps/devices/DevicesView.cpp
+392
View File
@@ -0,0 +1,392 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT license.
*
* Authors:
* Pieter Panman
*/
#include <Application.h>
#include <MenuBar.h>
#include "DevicesView.h"
DevicesView::DevicesView(const BRect& rect)
: BView(rect, "DevicesView", B_FOLLOW_ALL, B_WILL_DRAW | B_FRAME_EVENTS)
{
CreateLayout();
RescanDevices();
RebuildDevicesOutline();
}
void
DevicesView::CreateLayout()
{
SetLayout(new BGroupLayout(B_VERTICAL));
BMenuBar* menuBar = new BMenuBar("menu");
BMenu* menu = new BMenu("Devices");
BMenuItem* item;
menu->AddItem(new BMenuItem("Refresh Devices", new BMessage(kMsgRefresh), 'R'));
menu->AddItem(item = new BMenuItem("Report Compatibility",
new BMessage(kMsgReportCompatibility)));
item->SetEnabled(false);
menu->AddItem(item = new BMenuItem("Generate System Information",
new BMessage(kMsgGenerateSysInfo)));
item->SetEnabled(false);
menu->AddSeparatorItem();
menu->AddItem(item = new BMenuItem("About Devices" B_UTF8_ELLIPSIS,
new BMessage(B_ABOUT_REQUESTED)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
menu->SetTargetForItems(this);
item->SetTarget(be_app);
menuBar->AddItem(menu);
fDevicesOutline = new BOutlineListView("devices_list");
fDevicesOutline->SetTarget(this);
fDevicesOutline->SetSelectionMessage(new BMessage(kMsgSelectionChanged));
BScrollView *scrollView = new BScrollView("devicesScrollView",
fDevicesOutline, B_WILL_DRAW | B_FRAME_EVENTS, true, true);
// Horizontal scrollbar doesn't behave properly like the vertical
// scrollbar... If you make the view bigger (exposing a larger percentage
// of the view), it does not adjust the width of the scroll 'dragger'
// why? Bug? In scrollview or in outlinelistview?
BPopUpMenu* orderByPopupMenu = new BPopUpMenu("orderByMenu");
BMenuItem* byCategory = new BMenuItem("category",
new BMessage(kMsgOrderCategory));
BMenuItem* byConnection = new BMenuItem("connection",
new BMessage(kMsgOrderConnection));
byCategory->SetMarked(true);
fOrderBy = byCategory->IsMarked() ? ORDER_BY_CATEGORY :
ORDER_BY_CONNECTION;
orderByPopupMenu->AddItem(byCategory);
orderByPopupMenu->AddItem(byConnection);
fOrderByMenu = new BMenuField("Order by:", orderByPopupMenu);
fTabView = new BTabView("fTabView", B_WIDTH_FROM_LABEL);
fBasicTab = new BTab();
fBasicView = new PropertyListPlain("basicView");
fTabView->AddTab(fBasicView, fBasicTab);
fBasicTab->SetLabel("Basic Information");
fDeviceTypeTab = new BTab();
fBusView = new PropertyListPlain("busView");
fTabView->AddTab(fBusView, fDeviceTypeTab);
fDeviceTypeTab->SetLabel("Bus");
fDetailedTab = new BTab();
fAttributesView = new PropertyList("attributesView");
fTabView->AddTab(fAttributesView, fDetailedTab);
fDetailedTab->SetLabel("Detailed");
AddChild(BGroupLayoutBuilder(B_VERTICAL,0)
.Add(menuBar)
.Add(BSplitLayoutBuilder(B_HORIZONTAL, 5)
.Add(BGroupLayoutBuilder(B_VERTICAL, 5)
.Add(fOrderByMenu, 1)
.Add(scrollView, 2)
)
.Add(fTabView, 2)
.SetInsets(5, 5, 5, 5)
)
);
}
void
DevicesView::RescanDevices()
{
// Empty the outline and delete the devices in the list, incl. categories
fDevicesOutline->MakeEmpty();
DeleteDevices();
DeleteCategoryMap();
// Fill the devices list
status_t error;
device_node_cookie rootCookie;
if ((error = init_dm_wrapper()) < 0) {
std::cerr << "Error initializing device manager: " << strerror(error)
<< std::endl;
return;
}
get_root(&rootCookie);
AddDeviceAndChildren(&rootCookie, NULL);
uninit_dm_wrapper();
CreateCategoryMap();
}
void
DevicesView::DeleteDevices()
{
while(fDevices.size() > 0) {
delete fDevices.back();
fDevices.pop_back();
}
}
void
DevicesView::CreateCategoryMap()
{
CategoryMapIterator iter;
for (unsigned int i = 0; i < fDevices.size(); i++) {
Category category = fDevices[i]->GetCategory();
const char* categoryName = kCategoryString[category];
iter = fCategoryMap.find(category);
if( iter == fCategoryMap.end() ) {
// This category has not yet been added, add it.
fCategoryMap[category] = new Device(NULL, BUS_NONE, CAT_NONE,
categoryName);
}
}
}
void
DevicesView::DeleteCategoryMap()
{
CategoryMapIterator iter;
for(iter = fCategoryMap.begin(); iter != fCategoryMap.end(); iter++) {
delete iter->second;
}
fCategoryMap.clear();
}
int
DevicesView::SortItemsCompare(const BListItem *item1,
const BListItem *item2)
{
const BStringItem* stringItem1 = dynamic_cast<const BStringItem*>(item1);
const BStringItem* stringItem2 = dynamic_cast<const BStringItem*>(item2);
if (!(stringItem1 && stringItem2)) {
// is this check necessary?
std::cerr << "Could not cast BListItem to BStringItem, file a bug\n";
return 0;
}
return Compare(stringItem1->Text(),stringItem2->Text());
}
void
DevicesView::RebuildDevicesOutline()
{
// Rearranges existing Devices into the proper hierarchy
fDevicesOutline->MakeEmpty();
if (fOrderBy == ORDER_BY_CONNECTION) {
for (unsigned int i = 0; i < fDevices.size(); i++) {
if (fDevices[i]->GetPhysicalParent() == NULL) {
// process each parent device and its children
fDevicesOutline->AddItem(fDevices[i]);
AddChildrenToOutlineByConnection(fDevices[i]);
}
}
}
else if (fOrderBy == ORDER_BY_CATEGORY) {
// Add all categories to the outline
CategoryMapIterator iter;
for (iter = fCategoryMap.begin(); iter != fCategoryMap.end(); iter++) {
fDevicesOutline->AddItem(iter->second);
}
// Add all devices under the categories
for (unsigned int i = 0; i < fDevices.size(); i++) {
Category category = fDevices[i]->GetCategory();
iter = fCategoryMap.find(category);
if(iter == fCategoryMap.end()) {
std::cerr << "Tried to add device without category, file a bug\n";
continue;
}
else {
fDevicesOutline->AddUnder(fDevices[i], iter->second);
}
}
fDevicesOutline->SortItemsUnder(NULL, true, SortItemsCompare);
}
// TODO: Implement BY_BUS
}
void
DevicesView::AddChildrenToOutlineByConnection(Device* parent)
{
for (unsigned int i = 0; i < fDevices.size(); i++) {
if (fDevices[i]->GetPhysicalParent() == parent) {
fDevicesOutline->AddUnder(fDevices[i], parent);
AddChildrenToOutlineByConnection(fDevices[i]);
}
}
}
void
DevicesView::AddDeviceAndChildren(device_node_cookie *node, Device* parent)
{
Attributes attributes;
Device* newDevice = NULL;
// Copy all its attributes,
// necessary because we can only request them once from the device manager
char data[256];
struct device_attr_info attr;
attr.cookie = 0;
attr.node_cookie = *node;
attr.value.raw.data = data;
attr.value.raw.length = sizeof(data);
while (dm_get_next_attr(&attr) == B_OK) {
BString attrString;
switch (attr.type) {
case B_STRING_TYPE:
attrString << attr.value.string;
break;
case B_UINT8_TYPE:
attrString << attr.value.ui8;
break;
case B_UINT16_TYPE:
attrString << attr.value.ui16;
break;
case B_UINT32_TYPE:
attrString << attr.value.ui32;
break;
case B_UINT64_TYPE:
attrString << attr.value.ui64;
break;
default:
attrString << "Raw data";
}
attributes.push_back(Attribute(attr.name, attrString));
}
// Determine what type of device it is and create it
for (unsigned int i = 0; i < attributes.size(); i++) {
// Devices Root
if (attributes[i].fName == "device/pretty name"
&& attributes[i].fValue == "Devices Root") {
newDevice = new Device(parent, BUS_NONE, CAT_COMPUTER, "Computer");
break;
}
// PCI bus
if (attributes[i].fName == "device/pretty name"
&& attributes[i].fValue == "PCI") {
newDevice = new Device(parent, BUS_PCI, CAT_BUS, "PCI Bus");
break;
}
// ISA bus
if (attributes[i].fName == "device/bus"
&& attributes[i].fValue == "isa") {
newDevice = new Device(parent, BUS_ISA, CAT_BUS, "ISA Bus");
break;
}
// PCI device
if (attributes[i].fName == B_DEVICE_BUS
&& attributes[i].fValue == "pci") {
newDevice = new DevicePCI(parent);
break;
}
}
if (newDevice == NULL) {
newDevice = new Device(parent, BUS_NONE, CAT_NONE, "Unknown Device");
}
// Add its attributes to the device, initialize it and add to the list.
for (unsigned int i = 0; i < attributes.size(); i++) {
newDevice->SetAttribute(attributes[i].fName, attributes[i].fValue);
}
newDevice->InitFromAttributes();
fDevices.push_back(newDevice);
// Process children
status_t err;
device_node_cookie child = *node;
if (get_child(&child) != B_OK)
return;
do {
AddDeviceAndChildren(&child, newDevice);
} while ((err = get_next_child(&child)) == B_OK);
}
DevicesView::~DevicesView()
{
DeleteDevices();
}
void
DevicesView::MessageReceived(BMessage *msg)
{
switch (msg->what) {
case kMsgSelectionChanged:
{
int32 selected = fDevicesOutline->CurrentSelection(0);
if (selected >= 0) {
Device* device = (Device*)fDevicesOutline->ItemAt(selected);
fBasicView->AddAttributes(device->GetBasicAttributes());
fBusView->AddAttributes(device->GetBusAttributes());
fAttributesView->AddAttributes(device->GetAllAttributes());
fDeviceTypeTab->SetLabel(device->GetBusTabName());
// hmm the label doesn't automatically refresh
fTabView->Invalidate();
}
break;
}
case kMsgOrderCategory:
{
fOrderBy = ORDER_BY_CATEGORY;
RescanDevices();
RebuildDevicesOutline();
break;
}
case kMsgOrderConnection:
{
fOrderBy = ORDER_BY_CONNECTION;
RescanDevices();
RebuildDevicesOutline();
break;
}
case kMsgRefresh:
{
RescanDevices();
RebuildDevicesOutline();
break;
}
case kMsgReportCompatibility:
{
break;
}
case kMsgGenerateSysInfo:
{
break;
}
default:
BView::MessageReceived(msg);
break;
}
}
src/apps/devices/DevicesView.h
+85
View File
@@ -0,0 +1,85 @@
/*
* Copyright 2008-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT license.
*
* Authors:
* Pieter Panman
*/
#ifndef DEVICESVIEW_H
#define DEVICESVIEW_H
#include <GroupLayout.h>
#include <GroupLayoutBuilder.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <OutlineListView.h>
#include <PopUpMenu.h>
#include <SplitLayoutBuilder.h>
#include <ScrollView.h>
#include <String.h>
#include <StringView.h>
#include <TabView.h>
#include <View.h>
#include <map>
#include "Device.h"
#include "DevicePCI.h"
#include "PropertyList.h"
#include "PropertyListPlain.h"
static const uint32 kMsgRefresh = 'refr';
static const uint32 kMsgReportCompatibility = 'repo';
static const uint32 kMsgGenerateSysInfo = 'sysi';
static const uint32 kMsgSelectionChanged = 'selc';
static const uint32 kMsgOrderCategory = 'ocat';
static const uint32 kMsgOrderConnection = 'ocon';
typedef enum {
ORDER_BY_CONNECTION,
ORDER_BY_CATEGORY
} OrderByType;
typedef std::map<Category, Device*> CategoryMap;
typedef std::map<Category, Device*>::const_iterator CategoryMapIterator;
typedef std::vector<Device*> Devices;
class DevicesView : public BView {
public:
DevicesView(const BRect& r);
~DevicesView();
virtual void CreateLayout();
virtual void MessageReceived(BMessage* msg);
virtual void RescanDevices();
virtual void CreateCategoryMap();
virtual void DeleteCategoryMap();
virtual void DeleteDevices();
virtual void RebuildDevicesOutline();
virtual void AddChildrenToOutlineByConnection(Device* parent);
virtual void AddDeviceAndChildren(device_node_cookie* node,
Device* parent);
static int SortItemsCompare(const BListItem*, const BListItem*);
private:
BOutlineListView* fDevicesOutline;
PropertyListPlain* fBasicView;
PropertyListPlain* fBusView;
PropertyList* fAttributesView;
BMenuField* fOrderByMenu;
BTabView* fTabView;
Devices fDevices;
OrderByType fOrderBy;
CategoryMap fCategoryMap;
BTab* fBasicTab;
BTab* fDeviceTypeTab;
BTab* fDetailedTab;
};
#endif /* DEVICESVIEW_H */
src/apps/devices/DevicesWindow.cpp
-507
View File
@@ -1,507 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2003-2004, OpenBeOS
//
// This software is part of the OpenBeOS distribution and is covered
// by the OpenBeOS license.
//
//
// File: DevicesWindow.cpp
// Author: Sikosis, Jérôme Duval
// Description: Devices Preferences
// Created : March 04, 2003
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// Includes -------------------------------------------------------------------------------------------------- //
#include <Alert.h>
#include <Application.h>
#include <Box.h>
#include <Button.h>
#include <ClassInfo.h>
#include <File.h>
#include <FindDirectory.h>
#include <MenuBar.h>
#include <Menu.h>
#include <MenuItem.h>
#include <OutlineListView.h>
#include <Path.h>
#include <Screen.h>
#include <ScrollView.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <String.h>
#include <StringView.h>
#include "DevicesWindows.h"
#include "DevicesInfo.h"
const uint32 MENU_FILE_ABOUT_DEVICES = 'mfad';
const uint32 MENU_FILE_QUIT = 'mfqt';
const uint32 MENU_DEVICES_REMOVE_JUMPERED_DEVICE = 'mdrj';
const uint32 MENU_DEVICES_NEW_JUMPERED_DEVICE = 'mdnj';
const uint32 MENU_DEVICES_NEW_JUMPERED_DEVICE_CUSTOM = 'mdcj';
const uint32 MENU_DEVICES_NEW_JUMPERED_DEVICE_MODEM = 'mdcm';
const uint32 MENU_DEVICES_RESOURCE_USAGE = 'mdru';
const uint32 BTN_CONFIGURE = 'bcfg';
const uint32 SELECTION_CHANGED = 'slch';
// DevicesWindow - Constructor
DevicesWindow::DevicesWindow(BRect frame) : BWindow (frame, "Devices", B_TITLED_WINDOW, B_NORMAL_WINDOW_FEEL , 0)
{
InitWindow();
CenterOnScreen();
// Load User Settings
BPath path;
find_directory(B_USER_SETTINGS_DIRECTORY,&path);
path.Append("Devices_Settings",true);
BFile file(path.Path(),B_READ_ONLY);
BMessage msg;
msg.Unflatten(&file);
LoadSettings (&msg);
status_t error;
if ((error = init_cm_wrapper()) < 0) {
printf("Error initializing configuration manager (%s)\n", strerror(error));
exit(1);
}
InitDevices(B_ISA_BUS);
InitDevices(B_PCI_BUS);
for (int32 i=fList.CountItems()-1; i>=0; i--) {
DevicesInfo *deviceInfo = (DevicesInfo *) fList.ItemAt(i);
struct device_info *info = deviceInfo->GetInfo();
BListItem *item = systemMenu;
if (info->bus == B_ISA_BUS) {
uint32 id = info->id[0];
if ((id >> 24 == 'P')
&& (((id >> 16) & 0xff) == 'n')
&& (((id >> 8) & 0xff) == 'P')) {
item = isaMenu;
} else {
item = systemMenu;
}
} else if (info->bus == B_PCI_BUS)
item = pciMenu;
outline->AddUnder(new DeviceItem(deviceInfo, deviceInfo->GetCardName()), item);
}
if (outline->CountItemsUnder(jumperedMenu, true)==0)
outline->AddUnder(new BStringItem("<no devices>"), jumperedMenu);
if (outline->CountItemsUnder(pciMenu, true)==0)
outline->AddUnder(new BStringItem("<no devices>"), pciMenu);
if (outline->CountItemsUnder(isaMenu, true)==0)
outline->AddUnder(new BStringItem("<no devices>"), isaMenu);
if (outline->CountItemsUnder(systemMenu, true)==0)
outline->AddUnder(new BStringItem("<no devices>"), systemMenu);
Show();
}
// ---------------------------------------------------------------------------------------------------------- //
// DevicesWindow - Destructor
DevicesWindow::~DevicesWindow()
{
void *item;
while ((item = fList.RemoveItem((int32)0)))
delete (DevicesInfo*)item;
uninit_cm_wrapper();
}
// ---------------------------------------------------------------------------------------------------------- //
// DevicesWindow::InitWindow -- Initialization Commands here
void DevicesWindow::InitWindow(void)
{
BRect r;
r = Bounds(); // the whole view
BMenuItem *mniRemoveJumperedDevice;
// Add the menu bar
menubar = new BMenuBar(r, "menu_bar");
// Add File menu to menu bar
BMenu *menu = new BMenu("File");
menu->AddItem(new BMenuItem("About Devices" B_UTF8_ELLIPSIS, new BMessage(MENU_FILE_ABOUT_DEVICES), 0));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Quit", new BMessage(MENU_FILE_QUIT), 'Q'));
menubar->AddItem(menu);
menu = new BMenu("Devices");
menubar->AddItem(menu);
BMenu *jumperedDevicesMenu = new BMenu("New Jumpered Device");
jumperedDevicesMenu->AddItem(new BMenuItem("Custom" B_UTF8_ELLIPSIS, new BMessage(MENU_DEVICES_NEW_JUMPERED_DEVICE_CUSTOM), 0));
jumperedDevicesMenu->AddItem(new BMenuItem("Modem" B_UTF8_ELLIPSIS, new BMessage(MENU_DEVICES_NEW_JUMPERED_DEVICE_MODEM), 0));
//DevicesMenu->AddItem(new BMenuItem("New Jumpered Device", new BMessage(MENU_DEVICES_NEW_JUMPERED_DEVICE), NULL));
menu->AddItem(jumperedDevicesMenu);
menu->AddItem(mniRemoveJumperedDevice = new BMenuItem("Remove Jumpered Device", new BMessage(MENU_DEVICES_REMOVE_JUMPERED_DEVICE), 'R'));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Resource Usage", new BMessage(MENU_DEVICES_RESOURCE_USAGE), 'U'));
mniRemoveJumperedDevice->SetEnabled(false);
// Create the StringViews
stvDeviceName = new BStringView(BRect(16, 16, 150, 40), "DeviceName", "Device Name");
stvCurrentState = new BStringView(BRect(248, 16, r.right-10, 40), "CurrentState", "Current State");
float fCurrentHeight = 279;
float fCurrentGap = 15;
stvIRQ = new BStringView(BRect(r.left+22,r.top+fCurrentHeight,r.right-13,r.top+fCurrentHeight+20),"IRQ","IRQs:", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
fCurrentHeight = fCurrentHeight + fCurrentGap;
stvDMA = new BStringView(BRect(r.left+22,r.top+fCurrentHeight,r.right-13,r.top+fCurrentHeight+20),"DMA","DMAs:", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
fCurrentHeight = fCurrentHeight + fCurrentGap;
stvIORanges = new BStringView(BRect(r.left+22,r.top+fCurrentHeight,r.right-13,r.top+fCurrentHeight+20),"IORanges","IO Ranges:", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
fCurrentHeight = fCurrentHeight + fCurrentGap;
stvMemoryRanges = new BStringView(BRect(r.left+22,r.top+fCurrentHeight,r.right-13,r.top+fCurrentHeight+20),"MemoryRanges","Memory Ranges:", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
fCurrentHeight = fCurrentHeight + fCurrentGap;
// Create the OutlineView
BRect outlinerect(r.left+14,r.top+45,r.right-28,r.top+262);
BScrollView *outlinesv;
outline = new BOutlineListView(outlinerect,"devices_list", B_SINGLE_SELECTION_LIST, B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM);
outline->AddItem(systemMenu = new DeviceItem(NULL, "System Devices"));
outline->AddItem(isaMenu = new DeviceItem(NULL, "ISA/Plug and Play Devices"));
outline->AddItem(pciMenu = new DeviceItem(NULL, "PCI Devices"));
outline->AddItem(jumperedMenu = new DeviceItem(NULL, "Jumpered Devices"));
outline->SetSelectionMessage(new BMessage(SELECTION_CHANGED));
outline->SetInvocationMessage(new BMessage(BTN_CONFIGURE));
// Add ScrollView to Devices Window
outlinesv = new BScrollView("scroll_devices", outline, B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM, 0, false, true, B_FANCY_BORDER);
// Setup the OutlineView
outline->AllAttached();
outlinesv->SetBorderHighlighted(true);
// Back and Fore ground Colours
outline->SetHighColor(0,0,0,0);
outline->SetLowColor(255,255,255,0);
// Font Settings
BFont OutlineFont;
OutlineFont.SetSpacing(B_CHAR_SPACING);
OutlineFont.SetSize(12);
outline->SetFont(&OutlineFont,B_FONT_SHEAR | B_FONT_SPACING);
// Create BBox (or Frame)
BBox *BottomFrame;
BRect BottomFrameRect(r.left+11,r.bottom-124,r.right-12,r.bottom-12);
BottomFrame = new BBox(BottomFrameRect, "BottomFrame", B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM, B_WILL_DRAW, B_FANCY_BORDER);
BRect bottomFrameBounds = BottomFrame->Bounds();
// Create BButton - Configure
BRect ConfigureButtonRect(bottomFrameBounds.left+290, bottomFrameBounds.bottom-37,
bottomFrameBounds.right-13, bottomFrameBounds.bottom-13);
btnConfigure = new BButton(ConfigureButtonRect,"btnConfigure","Configure", new BMessage(BTN_CONFIGURE), B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, B_WILL_DRAW | B_NAVIGABLE);
btnConfigure->MakeDefault(true);
btnConfigure->SetEnabled(false);
// Create a basic View
BBox *background = new BBox(Bounds(), "background", B_FOLLOW_ALL_SIDES, B_WILL_DRAW, B_PLAIN_BORDER);
AddChild(background);
// Add Child(ren) - in reverse order to avoid one control overwriting another
background->AddChild(BottomFrame);
BottomFrame->AddChild(btnConfigure);
background->AddChild(outlinesv);
background->AddChild(stvMemoryRanges);
background->AddChild(stvIORanges);
background->AddChild(stvDMA);
background->AddChild(stvIRQ);
background->AddChild(stvDeviceName);
background->AddChild(stvCurrentState);
background->AddChild(menubar);
// Set Window Limits
float xsize = 396 + (be_plain_font->Size()-10)*40;
if (xsize > 443)
xsize = 443;
SetSizeLimits(xsize,xsize,400,BScreen().Frame().Height());
}
// ---------------------------------------------------------------------------------------------------------- //
// DevicesWindow::QuitRequested -- Post a message to the app to quit
bool DevicesWindow::QuitRequested()
{
SaveSettings();
be_app->PostMessage(B_QUIT_REQUESTED);
return true;
}
// ---------------------------------------------------------------------------------------------------------- //
// DevicesWindow::LoadSettings -- Loads your current settings
void DevicesWindow::LoadSettings(BMessage *msg)
{
BRect frame;
if (B_OK == msg->FindRect("windowframe",&frame)) {
MoveTo(frame.left,frame.top);
ResizeTo(frame.right-frame.left,frame.bottom-frame.top);
}
}
// -------------------------------------------------------------------------------------------------------------- //
// DevicesWindow::SaveSettings -- Saves the Users settings
void DevicesWindow::SaveSettings(void)
{
BMessage msg;
msg.AddRect("windowframe",Frame());
BPath path;
status_t result = find_directory(B_USER_SETTINGS_DIRECTORY,&path);
if (result == B_OK)
{
path.Append("Devices_Settings",true);
BFile file(path.Path(),B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
msg.Flatten(&file);
}
}
// ------------------------------------------------------------------------------- //
// DevicesWindow::MessageReceived -- receives messages
void
DevicesWindow::MessageReceived (BMessage *message)
{
switch(message->what)
{
case MENU_FILE_ABOUT_DEVICES:
{
(new BAlert("", "Devices\n\n\t'Just write a simple app to add a jumpered\n\tdevice to the system', he said.\n\n\tAnd many years later another he said\n\t'recreate it' ;)", "OK"))->Go();
}
break;
case MENU_FILE_QUIT:
{
QuitRequested();
}
break;
case MENU_DEVICES_NEW_JUMPERED_DEVICE_MODEM:
{
ptrModemWindow = new ModemWindow(BRect(0,0,200,194), BMessenger(this));
}
break;
case MENU_DEVICES_RESOURCE_USAGE:
{
ptrResourceUsageWindow = new ResourceUsageWindow(BRect(0,0,430,350), fList);
}
break;
case SELECTION_CHANGED:
{
UpdateDeviceInfo();
}
break;
case MODEM_ADDED:
{
}
break;
case BTN_CONFIGURE:
{
DeviceItem *devItem = dynamic_cast<DeviceItem *>(outline->ItemAt(outline->CurrentSelection()));
if (devItem && devItem->GetInfo()) {
if (devItem->GetWindow()!=NULL)
devItem->GetWindow()->Activate();
else
new ConfigurationWindow(BRect(150,150,562,602), devItem);
}
}
break;
default:
BWindow::MessageReceived(message);
break;
}
UpdateIfNeeded();
}
// ---------------------------------------------------------------------------------------------------------- //
void
DevicesWindow::InitDevices(bus_type bus)
{
status_t size;
uint64 cookie;
struct device_info dummy, *info;
struct device_configuration *current;
struct possible_device_configurations *possible;
cookie = 0;
while (get_next_device_info(bus, &cookie, &dummy, sizeof(dummy)) == B_OK) {
info = (struct device_info *)malloc(dummy.size);
if (!info) {
printf("Out of core\n");
break;
}
if (get_device_info_for(cookie, info, dummy.size) != B_OK) {
printf("Error getting device information\n");
break;
}
size = get_size_of_current_configuration_for(cookie);
if (size < B_OK) {
printf("Error getting the size of the current configuration\n");
break;
}
current = (struct device_configuration *)malloc(size);
if (!current) {
printf("Out of core\n");
break;
}
if (get_current_configuration_for(cookie, current, size) != B_OK) {
printf("Error getting the current configuration\n");
break;
}
size = get_size_of_possible_configurations_for(cookie);
if (size < B_OK) {
printf("Error getting the size of the possible configurations\n");
break;
}
possible = (struct possible_device_configurations *)malloc(size);
if (!possible) {
printf("Out of core\n");
break;
}
if (get_possible_configurations_for(cookie, possible, size) != B_OK) {
printf("Error getting the possible configurations\n");
break;
}
fList.AddItem(new DevicesInfo(info, current, possible));
}
}
void
DevicesWindow::UpdateDeviceInfo()
{
DeviceItem *item = dynamic_cast<DeviceItem *>(outline->ItemAt(outline->CurrentSelection()));
if (item) {
DevicesInfo *deviceInfo = item->GetInfo();
if (deviceInfo) {
struct device_configuration *current = deviceInfo->GetCurrent();
resource_descriptor r;
{
BString text = "IRQs: ";
bool first = true;
int32 num = count_resource_descriptors_of_type(current, B_IRQ_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_IRQ_RESOURCE,
&r, sizeof(resource_descriptor));
uint32 mask = r.d.m.mask;
int i = 0;
if (!mask)
continue;
for (;mask;mask>>=1,i++)
if (mask & 1) {
char value[50];
sprintf(value, "%s%d", first ? "" : ", ", i);
text += value;
first = false;
}
}
stvIRQ->SetText(text.String());
}
{
BString text = "DMAs: ";
bool first = true;
int32 num = count_resource_descriptors_of_type(current, B_DMA_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_DMA_RESOURCE,
&r, sizeof(resource_descriptor));
uint32 mask = r.d.m.mask;
int i = 0;
if (!mask)
continue;
for (;mask;mask>>=1,i++)
if (mask & 1) {
char value[50];
sprintf(value, "%s%d", first ? "" : ", ", i);
text += value;
first = false;
}
}
stvDMA->SetText(text.String());
}
{
BString text = "IO Ranges: ";
bool first = true;
int32 num = count_resource_descriptors_of_type(current, B_IO_PORT_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_IO_PORT_RESOURCE,
&r, sizeof(resource_descriptor));
char value[50];
sprintf(value, "%s0x%04lx - 0x%04lx", first ? "" : ", ", r.d.r.minbase, r.d.r.minbase + r.d.r.len - 1);
text += value;
first = false;
}
if (text.Length()>70) {
text.Truncate(70);
text += B_UTF8_ELLIPSIS;
}
stvIORanges->SetText(text.String());
}
{
BString text = "Memory Ranges: ";
bool first = true;
int32 num = count_resource_descriptors_of_type(current, B_MEMORY_RESOURCE);
for (int32 i=0;i<num;i++) {
get_nth_resource_descriptor_of_type(current, i, B_MEMORY_RESOURCE,
&r, sizeof(resource_descriptor));
char value[50];
sprintf(value, "%s0x%06lx - 0x%06lx", first ? "" : ", ", r.d.r.minbase, r.d.r.minbase + r.d.r.len - 1);
text += value;
first = false;
}
if (text.Length()>70) {
text.Truncate(70);
text += B_UTF8_ELLIPSIS;
}
stvMemoryRanges->SetText(text.String());
}
btnConfigure->SetEnabled(true);
} else {
BlankDeviceInfoBox();
}
} else {
BlankDeviceInfoBox();
}
}
void
DevicesWindow::BlankDeviceInfoBox()
{
stvIRQ->SetText("IRQs: ");
stvDMA->SetText("DMAs: ");
stvIORanges->SetText("IO Ranges: ");
stvMemoryRanges->SetText("Memory Ranges: ");
btnConfigure->SetEnabled(false);
}
src/apps/devices/DevicesWindows.h
-106
View File
@@ -1,106 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2003-2004, OpenBeOS
//
// This software is part of the OpenBeOS distribution and is covered
// by the OpenBeOS license.
//
//
// File: DevicesWindows.h
// Author: Sikosis, Jérôme Duval
// Description: Devices Preferences
// Created : March 04, 2003
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
#ifndef __DEVICESWINDOWS_H__
#define __DEVICESWINDOWS_H__
#include <ListView.h>
#include <Menu.h>
#include <PopUpMenu.h>
#include <Window.h>
#include "DevicesInfo.h"
#include "cm_wrapper.h"
class BMenuField;
class BStringView;
#define MODEM_ADDED 'moad'
class ResourceUsageWindow : public BWindow {
public:
ResourceUsageWindow(BRect frame, BList &);
~ResourceUsageWindow();
virtual void MessageReceived(BMessage *message);
private:
void InitWindow(BList &);
};
class ModemWindow : public BWindow {
public:
ModemWindow(BRect frame, BMessenger);
~ModemWindow();
virtual void MessageReceived(BMessage *message);
private:
void InitWindow(void);
BMessenger fMessenger;
};
class ConfigurationWindow : public BWindow {
public:
ConfigurationWindow(BRect frame, DeviceItem *item);
~ConfigurationWindow();
virtual bool QuitRequested();
virtual void MessageReceived(BMessage *message);
private:
void InitWindow(void);
DeviceItem *fItem;
BMenu *fConfigurationMenu;
BPopUpMenu *fIRQMenu[3];
BMenuField *fIRQField[3];
BPopUpMenu *fDMAMenu[3];
BMenuField *fDMAField[3];
BListView *ioListView, *memoryListView;
};
class DevicesWindow : public BWindow {
public:
DevicesWindow(BRect frame);
~DevicesWindow();
virtual bool QuitRequested();
virtual void MessageReceived(BMessage *message);
private:
void InitWindow(void);
void InitDevices(bus_type bus);
void LoadSettings(BMessage *msg);
void SaveSettings(void);
void UpdateDeviceInfo();
void BlankDeviceInfoBox();
ResourceUsageWindow* ptrResourceUsageWindow;
ModemWindow* ptrModemWindow;
BStringView *stvDeviceName;
BStringView *stvCurrentState;
BMenuBar *menubar;
BList fList;
BListItem *systemMenu, *isaMenu, *pciMenu, *jumperedMenu;
BOutlineListView *outline;
BStringView *stvIRQ;
BStringView *stvDMA;
BStringView *stvIORanges;
BStringView *stvMemoryRanges;
BButton *btnConfigure;
};
#endif
src/apps/devices/Documentation/Design.txt
+128
View File
@@ -0,0 +1,128 @@
DeviceManager Design
====================
Requirements
------------
1) Graphically list each device in the system, with all the information available for that specific device type:
- PCI
- USB
- SCSI
- Bluetooth?
- ISA?
- ATAPI?
- AHCI?
- Firewire?
2) Generate a comprehensive text listing of the devices present to allow users to share detailed information with developers
- Generate an email with this information attached
3) Let the user generate a report on how well Haiku supports the devices in the system.
- Present a list of devices and per device a star rating on the support, and provide a space for comments on the device support.
- For each device allow comments
- Include all available information for the device (including loaded driver)
- Perhaps this can go into the Haikuware compatibility database?
4) Arrange the devices in different orders (by category, by connection, by bus type, by resource assignment?)
Graphical Design
----------------
+=========+
| Devices |
+=========+======================================================+
| Devices | Help | |
+----------------------------------------------------------------+
| +------------------------+-----------------------------------+ |
| | Sort by: [Category v] | / Basic \/ <Bus> \/ Advanced \ | |
| | ------------------- | + +--------+----------+--+ | |
| | v Audio/Video Devices | | Device Name: Netlink 5787M | | |
| | Hauppauge WinTV | | Manufacturer: Broadcom | | |
| | Intel HDA Audio | | Category: Network Devices | | |
| | v Human Interface Dev. | | Driver used: broadcom570x | | |
| | USB Mouse | | | | |
| | USB Keyboard | | | | |
| | v Network Devices | | | | |
| | -->Broadcom 5787M<-- | | | | |
| | Intel 4965 WIFI | | | | |
| | v Graphics Card | | | | |
| | NVidia 8600M GT | | | | |
| | .... | +-------------------------------+ | |
| +------------------------+-----------------------------------+ |
| +-------------------------+ +------------+ +-----------+ |
| | Report hardware support | | Gen. email | | Gen. Text | |
| +-------------------------+ +------------+ +-----------+ |
+================================================================+
Menu:
Devices
- Refresh devices
- Report compatibility
- Generate system information
- -----
- About Devices
- -----
- Quit
Interface details:
- The left list is an OutlineListView,
- Is inside a scroll container
- Will contain nice icons per type/device
- Clicking on a device will show the details in the right view
- The right view contains 3 tabs:
- Basic tab: Information available for every kind device
- <Bus> tab: Information specific to the bus type of device. (PCI, USB, etc)
- Advanced tab: Has a list of name-value pairs of all available information
- Sort by allows the user to arrange the treeview by:
- Category:
- Connection
- Bus type
- Report Hardware Support
- List all devices
- For each device
When you click Report Hardware Support, this appears:
+=========================+
| Report Hardware Support |
+=========================+============================+
| Report Device Supported Comment |
| [x] Broadcom Netlink 5787M ***** _________ |
| [x] Hauppauge WinTV ***** _________ |
| [x] Intel 4965 WIFI ..... _________ |
| [x] Intel HDA Audio ****. _________ |
| [x] NVidia 8600M GT ***.. _________ |
| [x] USB Keyboard ***** _________ |
| [x] USB Mouse ***** _________ |
| [ ] Intel 82801 PCI Bridge ..... _________ |
| [ ] Intel 82801H PCI Express ..... _________ |
| |
| If you wish, you can leave your contact details so |
| developers can get in touch with you for questions |
| about your devices. These will be stored privately. |
| |
| Name: _______________ Email: __________________ |
| |
| Haiku-os.org account: __________________________ |
| |
| +--------------------+ +---------------+ |
| | Preview submission | | Generate File | |
| +--------------------+ +---------------+ |
+======================================================+
Interface details:
------------------
- All devices are _not_ selected for report by default
- As soon as a rating is given, it is selected to be reported
- Preview submission will popup the generated list with a submit button
- Generate file will generate a file that can be uploaded manually, or emailed to a specific address.
- As you mouse over the rating, a popup will appear detailing what each star stands for:
- ..... : No support
- X.... : Crashes Haiku
- **... : Detected but doesn't work with 3rd party driver
- ***.. : Detected but doesn't work out of the box
- ****. : Detected and works with 3rd party driver
- ***** : Detected and works out of the box
src/apps/devices/Documentation/Specification.txt
+69
View File
@@ -0,0 +1,69 @@
Each device has:
- Name (long/short)
- Manufacturer (long/short)
- Category (one master list, each bus type maps its device types onto the master list)
- Driver used
- Device paths
- Its bus type
- Its connection parent, if applicable
Each source has: (currently the RescanDevices method does this)
- Init function
- Scan method that returns the devices.
- DevManSource, USBSource, FWSource, ...
DeviceManager Specification
===========================
DeviceManager : BApplication
-------------
DeviceManagerView : BView
-----------------
Device : public BStringItem
------
BString GetName() const;
BString GetManufacturer() const;
Category GetCategory() const;
BString DriverUsed() const;
BString DevPathsPublished() const;
BView Get
private:
BString _name;
BString _manufacturer;
Category _category;
BString _driverUsed;
BString devPathsPublished;
map<BString, BString> _attributes;
Bus : public BStringItem
---
virtual bool IsPresent() const = 0;
virtual Scan() = 0;
virtual vector<Device *> Devices() = 0;
PCIBus : public Bus
------
PCIDevice: public Device
---------
ISABus : public Bus
-----
ISADevice : public Device
---------
USBBus : public Bus
------
USBDevice : public Device
---------
SCSIBus : public Bus
-------
SCSIDevice : public Device
----------
src/apps/devices/Documentation/Todo.txt
+13
View File
@@ -0,0 +1,13 @@
TODO:
* There still is a memory leak somewhere, hunt it down
* Make Get methods of Device const
* Fix view color?
* Fix forwarding of messages to view
* Bottom scrollbar strangeness
* Reduce executable size?
* Find a place for unknown devices (or decypher the names better)
* Reselect currently selected on sort-by change - unique device id (device_node_cookie?)
* Check for keyboard navigation
* Loading and saving settings (sort by, position, size and sizes of views)
* Icons per device type
* Index attributes by enum, not string
src/apps/devices/Jamfile
+16 -11
View File
@@ -1,6 +1,10 @@
SubDir HAIKU_TOP src apps devices ; SubDir HAIKU_TOP src apps devices ;
SetSubDirSupportedPlatformsBeOSCompatible ; UsePrivateHeaders shared ;
UsePrivateHeaders interface ;
UsePrivateKernelHeaders ;
UsePrivateSystemHeaders ;
rule ISAPnPHeaderGen rule ISAPnPHeaderGen
{ {
@@ -56,17 +60,18 @@ actions PCIHeaderGen1
PCIHeaderGen [ FGristFiles pcihdr.h ] : pci.ids : pci-header.awk ; PCIHeaderGen [ FGristFiles pcihdr.h ] : pci.ids : pci-header.awk ;
Preference Devices : Application Devices :
Devices.cpp DevicesApplication.cpp
DevicesWindow.cpp DevicesView.cpp
ResourceUsageWindow.cpp dm_wrapper.c
ModemWindow.cpp DevicePCI.cpp
cm_wrapper.c Device.cpp
DevicesInfo.cpp PropertyList.cpp
ConfigurationWindow.cpp PropertyListPlain.cpp
: be $(TARGET_LIBSUPC++) : be libcolumnlistview.a tracker $(TARGET_LIBSUPC++) $(TARGET_LIBSTDC++)
: Devices.rdef : Devices.rdef
; ;
Includes [ FGristFiles DevicesInfo.cpp ] : [ FGristFiles isapnpids.h usbdevs.h usbdevs_data.h ] ; Includes [ FGristFiles DevicesInfo.cpp ] : [ FGristFiles isapnpids.h usbdevs.h
usbdevs_data.h ] ;
Includes [ FGristFiles ConfigurationWindow.cpp ] : [ FGristFiles pcihdr.h ] ; Includes [ FGristFiles ConfigurationWindow.cpp ] : [ FGristFiles pcihdr.h ] ;
src/apps/devices/ModemWindow.cpp
-152
View File
@@ -1,152 +0,0 @@
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
// Copyright (c) 2003-2004, OpenBeOS
//
// This software is part of the OpenBeOS distribution and is covered
// by the OpenBeOS license.
//
//
// File: ModemWindow.cpp
// Author: Sikosis, Jérôme Duval
// Description: Devices Preferences
// Created : August 23, 2003
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// Includes ------------------------------------------------------------------------------------------ //
//#include <Application.h>
#include <Box.h>
#include <Button.h>
#include <MenuItem.h>
#include <MenuField.h>
//#include <Path.h>
//#include <PopUpMenu.h>
#include <Screen.h>
//#include <stdio.h>
//#include <String.h>
#include <TextView.h>
//#include <Window.h>
//#include <View.h>
#include "DevicesWindows.h"
// -------------------------------------------------------------------------------------------------- //
const uint32 BTN_ADD = 'badd';
const uint32 BTN_CANCEL = 'bcnl';
// -------------------------------------------------------------------------------------------------- //
// ModemWindow - Constructor
ModemWindow::ModemWindow(BRect frame, BMessenger messenger)
: BWindow (frame, "ModemWindow", B_MODAL_WINDOW_LOOK, B_MODAL_APP_WINDOW_FEEL, B_NOT_RESIZABLE),
fMessenger(messenger)
{
InitWindow();
CenterOnScreen();
Show();
}
// -------------------------------------------------------------------------------------------------- //
// ModemWindow - Destructor
ModemWindow::~ModemWindow()
{
}
// -------------------------------------------------------------------------------------------------- //
// ModemWindow::InitWindow -- Initialization Commands here
void
ModemWindow::InitWindow(void)
{
BRect r;
r = Bounds();
BBox *background = new BBox(r, "background", B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW, B_PLAIN_BORDER);
AddChild(background);
BBox *boxInternalModem = new BBox(BRect (r.left+9,r.top+9,r.right-11,r.bottom-44),
"boxInternalModem", B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW, B_FANCY_BORDER);
boxInternalModem->SetLabel("Internal Modem");
boxInternalModem->SetFont(be_plain_font);
rgb_color black = {0,0,0};
BRect rect = boxInternalModem->Bounds();
rect.left += 9;
rect.top += 58;
rect.right -= 11;
rect.bottom -= 20;
BRect textRect(rect);
textRect.OffsetTo(B_ORIGIN);
textRect.InsetBy(1,1);
BTextView *textView = new BTextView(rect, "text", textRect, be_plain_font, &black, B_FOLLOW_TOP | B_FOLLOW_LEFT, B_WILL_DRAW);
textView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
textView->SetText("This is intended for configuring\n"
"jumpered modem only. Plug and\n"
"Play modems are automatically\n"
"detected by the system.");
boxInternalModem->AddChild(textView);
BRect CancelButtonRect(29,r.bottom-34,104,r.bottom-13);
BButton *btnCancel = new BButton(CancelButtonRect,"btnCancel","Cancel",
new BMessage(BTN_CANCEL), B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW | B_NAVIGABLE);
BRect AddButtonRect(115,r.bottom-34,r.right - 10,r.bottom-13);
BButton *btnAdd = new BButton(AddButtonRect,"btnAdd","Add",
new BMessage(BTN_ADD), B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW | B_NAVIGABLE);
btnAdd->MakeDefault(true);
rect = boxInternalModem->Bounds();
rect.top += 28;
rect.left += 38;
rect.right = rect.left + 105;
rect.bottom = rect.top + 5;
BPopUpMenu *serialMenu = new BPopUpMenu("pick one");
BMenuItem *item;
serialMenu->AddItem(item = new BMenuItem("serial3 ", NULL));
item->SetMarked(true);
serialMenu->AddItem(item = new BMenuItem("serial4 ", NULL));
BMenuField *serialMenuField = new BMenuField(rect, "serialMenuField",
"Port:", serialMenu);
serialMenuField->SetDivider(40.0);
serialMenuField->SetAlignment(B_ALIGN_RIGHT);
boxInternalModem->AddChild(serialMenuField);
// Create the Views
background->AddChild(boxInternalModem);
background->AddChild(btnCancel);
background->AddChild(btnAdd);
}
// -------------------------------------------------------------------------------------------------- //
// ModemWindow::MessageReceived -- receives messages
void
ModemWindow::MessageReceived (BMessage *message)
{
switch(message->what)
{
case BTN_CANCEL:
{
Quit();
}
break;
case BTN_ADD:
{
fMessenger.SendMessage(MODEM_ADDED);
Quit();
}
break;
default:
BWindow::MessageReceived(message);
break;
}
}
// -------------------------------------------------------------------------------------------------- //
src/apps/devices/PropertyList.cpp
+91
View File
@@ -0,0 +1,91 @@
/*
* Copyright 2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT license.
*
* Authors:
* Pieter Panman
*/
#include "PropertyList.h"
#include <ColumnTypes.h>
//#include <stdio.h>
PropertyRow::PropertyRow(const char* name, const char* value)
: BRow(),
fName(name), fValue(value)
{
SetField(new BStringField(name), kNameColumn);
SetField(new BStringField(value), kValueColumn);
}
PropertyRow::~PropertyRow()
{
}
void
PropertyRow::SetName(const char* name)
{
fName = name;
SetField(new BStringField(name), kNameColumn);
}
void
PropertyRow::SetValue(const char* value)
{
fValue = value;
SetField(new BStringField(value), kValueColumn);
}
PropertyList::PropertyList(const char* name)
: BColumnListView(BRect(0.0, 0.0, 1.0, 1.0), name, B_FOLLOW_ALL, 0,
B_NO_BORDER, true)
{
BStringColumn* nameColumn;
AddColumn(nameColumn = new BStringColumn("Name", 150, 50, 500,
B_TRUNCATE_MIDDLE),
kNameColumn);
AddColumn(new BStringColumn("Value", 150, 50, 500, B_TRUNCATE_END),
kValueColumn);
SetSortColumn(nameColumn, false, true);
}
PropertyList::~PropertyList()
{
RemoveAll();
}
void
PropertyList::AddAttributes(const Attributes& attributes)
{
RemoveAll();
for (unsigned int i = 0; i < attributes.size(); i++) {
AddRow(new PropertyRow(attributes[i].fName, attributes[i].fValue));
}
}
void
PropertyList::RemoveAll()
{
BRow *row;
while ((row = RowAt((int32)0, NULL))!=NULL) {
RemoveRow(row);
delete row;
}
}
void
PropertyList::SelectionChanged()
{
}
src/apps/devices/PropertyList.h
+51
View File
@@ -0,0 +1,51 @@
/*
* Copyright 2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT license.
*
* Authors:
* Pieter Panman
*/
#ifndef PROPERTYLIST_H
#define PROPERTYLIST_H
#include <ColumnListView.h>
#include <String.h>
#include "Device.h"
struct Attribute;
enum {
kNameColumn,
kValueColumn
};
class PropertyRow : public BRow {
public:
PropertyRow(const char* name, const char* value);
virtual ~PropertyRow();
const char* Name() const { return fName.String(); }
const char* Value() const { return fValue.String(); }
void SetName(const char* name);
void SetValue(const char* value);
private:
BString fName;
BString fValue;
};
class PropertyList : public BColumnListView {
public:
PropertyList(const char* name = "Properties");
virtual ~PropertyList();
void RemoveAll();
void AddAttributes(const Attributes& attributes);
protected:
virtual void SelectionChanged();
};
#endif /* PROPERTYLIST_H*/
src/apps/devices/PropertyListPlain.cpp
+104
View File
@@ -0,0 +1,104 @@
/*
* Copyright 2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Author:
* Artur Wyszynski <[email protected]>
* Modified by Pieter Panman
*/
#include "PropertyListPlain.h"
#include <GridLayout.h>
#include <GridLayoutBuilder.h>
#include <GroupLayout.h>
#include <GroupLayoutBuilder.h>
#include <Message.h>
#include <SpaceLayoutItem.h>
#include <String.h>
#include <StringView.h>
#include "Device.h"
PropertyListPlain::PropertyListPlain(const char* name)
:
BView(name, 0, NULL)
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
SetLayout(new BGroupLayout(B_VERTICAL));
}
PropertyListPlain::~PropertyListPlain()
{
}
void
PropertyListPlain::AddAttributes(const Attributes& attributes)
{
RemoveAll();
BGridLayoutBuilder builder(5, 5);
unsigned int i;
for (i = 0; i < attributes.size(); i++) {
const char* name = attributes[i].fName;
const char* value = attributes[i].fValue;
BString tempViewName(name);
BStringView *nameView = new BStringView(tempViewName.String(), name);
tempViewName.Append("Value");
BStringView *valueView = new BStringView(tempViewName.String(), value);
nameView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
valueView->SetExplicitAlignment(BAlignment(B_ALIGN_LEFT,
B_ALIGN_VERTICAL_UNSET));
builder
.Add(nameView, 0, i)
.Add(valueView, 1, i);
}
// make sure that all content is left and top aligned
builder.Add(BSpaceLayoutItem::CreateGlue(), 2, i);
AddChild(BGroupLayoutBuilder(B_VERTICAL,5)
.Add(builder)
.SetInsets(5, 5, 5, 5)
);
}
void
PropertyListPlain::RemoveAll()
{
BView *child;
while((child = ChildAt(0))) {
RemoveChild(child);
delete child;
}
}
void
PropertyListPlain::MessageReceived(BMessage* message)
{
switch (message->what) {
default:
BView::MessageReceived(message);
}
}
void
PropertyListPlain::AttachedToWindow()
{
}
void
PropertyListPlain::DetachedFromWindow()
{
}
src/apps/devices/PropertyListPlain.h
+33
View File
@@ -0,0 +1,33 @@
/*
* Copyright 2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Author:
* Artur Wyszynski <[email protected]>
* Modified by Pieter Panman
*/
#ifndef PROPERTY_LIST_PLAIN_H
#define PROPERTY_LIST_PLAIN_H
#include <View.h>
#include "Device.h"
class PropertyListPlain : public BView {
public:
PropertyListPlain(const char* name);
virtual ~PropertyListPlain();
virtual void AddAttributes(const Attributes& attributes);
virtual void RemoveAll();
virtual void MessageReceived(BMessage* message);
virtual void AttachedToWindow();
virtual void DetachedFromWindow();
private:
BView* rootView;
};
#endif /* PROPERTY_LIST_PLAIN_H */
src/apps/devices/cm_wrapper.c
-141
View File
@@ -1,141 +0,0 @@
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include "cm_wrapper.h"
#include "config_driver.h"
static int fd;
status_t init_cm_wrapper(void)
{
static const char device[] = "/dev/" CM_DEVICE_NAME;
fd = open(device, 0);
if (fd < 0)
return errno;
return B_OK;
}
status_t uninit_cm_wrapper(void)
{
close(fd);
return B_OK;
}
status_t get_next_device_info(bus_type bus, uint64 *cookie,
struct device_info *info, uint32 size)
{
status_t result;
struct cm_ioctl_data params;
params.magic = CM_GET_NEXT_DEVICE_INFO;
params.bus = bus;
params.cookie = *cookie;
params.data = (void *)info;
params.data_len = size;
result = ioctl(fd, params.magic, &params, sizeof(params));
if (result == B_OK) *cookie = params.cookie;
return result;
}
status_t get_device_info_for(uint64 id, struct device_info *info,
uint32 size)
{
struct cm_ioctl_data params;
params.magic = CM_GET_DEVICE_INFO_FOR;
params.cookie = id;
params.data = (void *)info;
params.data_len = size;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t get_size_of_current_configuration_for(uint64 id)
{
struct cm_ioctl_data params;
params.magic = CM_GET_SIZE_OF_CURRENT_CONFIGURATION_FOR;
params.cookie = id;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t get_current_configuration_for(uint64 id,
struct device_configuration *current, uint32 size)
{
struct cm_ioctl_data params;
params.magic = CM_GET_CURRENT_CONFIGURATION_FOR;
params.cookie = id;
params.data = (void *)current;
params.data_len = size;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t get_size_of_possible_configurations_for(uint64 id)
{
struct cm_ioctl_data params;
params.magic = CM_GET_SIZE_OF_POSSIBLE_CONFIGURATIONS_FOR;
params.cookie = id;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t get_possible_configurations_for(uint64 id,
struct possible_device_configurations *possible, uint32 size)
{
struct cm_ioctl_data params;
params.magic = CM_GET_POSSIBLE_CONFIGURATIONS_FOR;
params.cookie = id;
params.data = (void *)possible;
params.data_len = size;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t count_resource_descriptors_of_type(
struct device_configuration *c, resource_type type)
{
struct cm_ioctl_data params;
params.magic = CM_COUNT_RESOURCE_DESCRIPTORS_OF_TYPE;
params.config = c;
params.type = type;
return ioctl(fd, params.magic, &params, sizeof(params));
}
status_t get_nth_resource_descriptor_of_type(
struct device_configuration *c, uint32 n,
resource_type type, resource_descriptor *d, uint32 size)
{
struct cm_ioctl_data params;
params.magic = CM_GET_NTH_RESOURCE_DESCRIPTOR_OF_TYPE;
params.config = c;
params.n = n;
params.type = type;
params.data = d;
params.data_len = size;
return ioctl(fd, params.magic, &params, sizeof(params));
}
uchar mask_to_value(uint32 mask)
{
uchar value;
if (!mask) return 0;
for (value=0,mask>>=1;mask;value++,mask>>=1)
;
return value;
}
src/apps/devices/cm_wrapper.h
-36
View File
@@ -1,36 +0,0 @@
#ifndef _CM_WRAPPER_H_
#define _CM_WRAPPER_H_
#include <drivers/config_manager.h>
#ifdef __cplusplus
extern "C" {
#endif
status_t init_cm_wrapper(void);
status_t uninit_cm_wrapper(void);
status_t get_next_device_info(bus_type bus, uint64 *cookie,
struct device_info *info, uint32 size);
status_t get_device_info_for(uint64 id, struct device_info *info,
uint32 size);
status_t get_size_of_current_configuration_for(uint64 id);
status_t get_current_configuration_for(uint64 id,
struct device_configuration *current, uint32 size);
status_t get_size_of_possible_configurations_for(uint64 id);
status_t get_possible_configurations_for(uint64 id,
struct possible_device_configurations *possible, uint32 size);
status_t count_resource_descriptors_of_type(
struct device_configuration *c, resource_type type);
status_t get_nth_resource_descriptor_of_type(
struct device_configuration *c, uint32 n, resource_type type,
resource_descriptor *d, uint32 size);
uchar mask_to_value(uint32 mask);
#ifdef __cplusplus
}
#endif
#endif
src/apps/devices/dm_wrapper.c
+69
View File
@@ -0,0 +1,69 @@
/*
* Copyright 2006 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jerome Duval (listdev)
*/
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <drivers/device_manager.h>
#include <device_manager_defs.h>
#include <generic_syscall_defs.h>
#include <string.h>
#include <syscalls.h>
#include "dm_wrapper.h"
status_t
init_dm_wrapper(void)
{
uint32 version = 0;
return _kern_generic_syscall(DEVICE_MANAGER_SYSCALLS, B_SYSCALL_INFO,
&version, sizeof(version));
}
status_t
uninit_dm_wrapper(void)
{
return B_OK;
}
status_t
get_root(device_node_cookie *cookie)
{
return _kern_generic_syscall(DEVICE_MANAGER_SYSCALLS, DM_GET_ROOT, cookie,
sizeof(device_node_cookie));
}
status_t
get_child(device_node_cookie *device)
{
return _kern_generic_syscall(DEVICE_MANAGER_SYSCALLS, DM_GET_CHILD, device,
sizeof(device_node_cookie));
}
status_t
get_next_child(device_node_cookie *device)
{
return _kern_generic_syscall(DEVICE_MANAGER_SYSCALLS, DM_GET_NEXT_CHILD,
device, sizeof(device_node_cookie));
}
status_t
dm_get_next_attr(struct device_attr_info *attr)
{
return _kern_generic_syscall(DEVICE_MANAGER_SYSCALLS,
DM_GET_NEXT_ATTRIBUTE, attr, sizeof(struct device_attr_info));
}
src/apps/devices/dm_wrapper.h
+21
View File
@@ -0,0 +1,21 @@
/*
* Copyright 2006 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jerome Duval (listdev)
*/
#ifndef DM_WRAPPER_H
#define DM_WRAPPER_H
#include "device_manager_defs.h"
status_t init_dm_wrapper(void);
status_t uninit_dm_wrapper(void);
status_t get_root(device_node_cookie *cookie);
status_t get_child(device_node_cookie *cookie);
status_t get_next_child(device_node_cookie *cookie);
status_t dm_get_next_attr(struct device_attr_info *attr);
#endif /* DM_WRAPPER_H */