haiku.git

/*
 * Copyright 2004-2015 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <NetworkSettingsAddOn.h>

#include <stdio.h>
#include <stdlib.h>

#include <ControlLook.h>
#include <NetworkAddress.h>
#include <NetworkInterface.h>
#include <NetworkSettings.h>

#include "NetworkWindow.h"


using namespace BNetworkKit;


BNetworkSettingsItem::BNetworkSettingsItem()
	:
	fProfile(NULL)
{
}


BNetworkSettingsItem::~BNetworkSettingsItem()
{
}


status_t
BNetworkSettingsItem::ProfileChanged(const BNetworkProfile* newProfile)
{
	fProfile = newProfile;
	return B_OK;
}


const BNetworkProfile*
BNetworkSettingsItem::Profile() const
{
	return fProfile;
}


void
BNetworkSettingsItem::SettingsUpdated(uint32 type)
{
}


void
BNetworkSettingsItem::ConfigurationUpdated(const BMessage& message)
{
}


void
BNetworkSettingsItem::NotifySettingsUpdated()
{
	// TODO: post to network window
	BMessage updated(kMsgSettingsItemUpdated);
	updated.AddPointer("item", this);
	gNetworkWindow.SendMessage(&updated);
}


// #pragma mark -


BNetworkSettingsInterfaceItem::BNetworkSettingsInterfaceItem(
	const char* interface)
	:
	fInterface(interface)
{
}


BNetworkSettingsInterfaceItem::~BNetworkSettingsInterfaceItem()
{
}


BNetworkSettingsType
BNetworkSettingsInterfaceItem::Type() const
{
	return B_NETWORK_SETTINGS_TYPE_INTERFACE;
}


const char*
BNetworkSettingsInterfaceItem::Interface() const
{
	return fInterface;
}


// #pragma mark -


BNetworkInterfaceListItem::BNetworkInterfaceListItem(int family,
	const char* interface, const char* label, BNetworkSettings& settings)
	:
	fSettings(settings),
	fFamily(family),
	fInterface(interface),
	fLabel(label),
	fDisabled(false),
	fLineOffset(0),
	fSpacing(0)
{
}


BNetworkInterfaceListItem::~BNetworkInterfaceListItem()
{
}


const char*
BNetworkInterfaceListItem::Label() const
{
	return fLabel;
}


void
BNetworkInterfaceListItem::DrawItem(BView* owner, BRect bounds, bool complete)
{
	owner->PushState();

	if (IsSelected() || complete) {
		if (IsSelected()) {
			owner->SetHighColor(ui_color(B_LIST_SELECTED_BACKGROUND_COLOR));
			owner->SetLowColor(owner->HighColor());
		} else
			owner->SetHighColor(owner->LowColor());

		owner->FillRect(bounds);
	}

	// Set the initial bounds of item contents
	BPoint labelLocation = bounds.LeftTop() + BPoint(fSpacing, fLineOffset);

	if (fDisabled) {
		rgb_color textColor;
		if (IsSelected())
			textColor = ui_color(B_LIST_SELECTED_ITEM_TEXT_COLOR);
		else
			textColor = ui_color(B_LIST_ITEM_TEXT_COLOR);

		if (textColor.red + textColor.green + textColor.blue > 128 * 3)
			owner->SetHighColor(tint_color(textColor, B_DARKEN_1_TINT));
		else
			owner->SetHighColor(tint_color(textColor, B_LIGHTEN_1_TINT));
	} else {
		if (IsSelected())
			owner->SetHighColor(ui_color(B_LIST_SELECTED_ITEM_TEXT_COLOR));
		else
			owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));
	}

	owner->SetFont(be_plain_font);
	owner->DrawString(fLabel, labelLocation);

	if (!fAddress.IsEmpty()) {
		BFont font = _AddressFont();
		owner->MovePenBy(fSpacing, 0);
		owner->SetFont(&font);
		owner->DrawString(fAddress);
	}

	owner->PopState();
}


void
BNetworkInterfaceListItem::Update(BView* owner, const BFont* font)
{
	_UpdateState();

	fSpacing = be_control_look->DefaultLabelSpacing();

	BListItem::Update(owner, font);
	font_height height;
	font->GetHeight(&height);

	float lineHeight = ceilf(height.ascent) + ceilf(height.descent)
		+ ceilf(height.leading);
	fLineOffset = 2 + ceilf(height.ascent + height.leading / 2);

	SetWidth(owner->StringWidth(fLabel) + 2 * fSpacing
		+ _AddressFont().StringWidth(fAddress.String()));
	SetHeight(lineHeight + 4);
}


void
BNetworkInterfaceListItem::ConfigurationUpdated(const BMessage& message)
{
	_UpdateState();
}


BFont
BNetworkInterfaceListItem::_AddressFont()
{
	BFont font;
	font.SetFace(B_ITALIC_FACE);
	font.SetSize(font.Size() * 0.9f);
	return font;
}


void
BNetworkInterfaceListItem::_UpdateState()
{
	BNetworkInterfaceAddress address;
	BNetworkInterface interface(fInterface);

	bool autoConfigure = fSettings.Interface(fInterface).IsAutoConfigure(
		fFamily);

	fAddress = "";
	fDisabled = !autoConfigure;

	int32 index = interface.FindFirstAddress(fFamily);
	if (index < 0)
		return;

	interface.GetAddressAt(index, address);

	fDisabled = address.Address().IsEmpty() && !autoConfigure;
	if (!address.Address().IsEmpty())
		fAddress << "(" << address.Address().ToString() << ")";
}


// #pragma mark -


BNetworkSettingsAddOn::BNetworkSettingsAddOn(image_id image,
	BNetworkSettings& settings)
	:
	fImage(image),
	fResources(NULL),
	fSettings(settings)
{
}


BNetworkSettingsAddOn::~BNetworkSettingsAddOn()
{
	delete fResources;
}


BNetworkSettingsInterfaceItem*
BNetworkSettingsAddOn::CreateNextInterfaceItem(uint32& cookie,
	const char* interface)
{
	return NULL;
}


BNetworkSettingsItem*
BNetworkSettingsAddOn::CreateNextItem(uint32& cookie)
{
	return NULL;
}


image_id
BNetworkSettingsAddOn::Image()
{
	return fImage;
}


BResources*
BNetworkSettingsAddOn::Resources()
{
	if (fResources == NULL) {
		image_info info;
		if (get_image_info(fImage, &info) != B_OK)
			return NULL;

		BResources* resources = new BResources();
		BFile file(info.name, B_READ_ONLY);
		if (resources->SetTo(&file) == B_OK)
			fResources = resources;
		else
			delete resources;
	}
	return fResources;
}


BNetworkSettings&
BNetworkSettingsAddOn::Settings()
{
	return fSettings;
}