haiku.git

/*
 * Copyright 2004-2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Alexander von Gluck IV, kallisti5@unixzen.com
 *		Philippe Houdoin
 * 		Fredrik Modéen
 *		John Scipione, jscipione@gmail.com
 */


#include "InterfaceListItem.h"

#include <algorithm>

#include <Application.h>
#include <Bitmap.h>
#include <Catalog.h>
#include <ControlLook.h>
#include <IconUtils.h>
#include <OutlineListView.h>
#include <Resources.h>
#include <String.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "InterfaceListItem"


InterfaceListItem::InterfaceListItem(const char* name,
	BNetworkInterfaceType type)
	:
	BListItem(0, false),
	fType(type),
	fIcon(NULL),
	fIconOffline(NULL),
	fIconPending(NULL),
	fIconOnline(NULL),
	fFirstLineOffset(0),
	fLineOffset(0),
	fDisabled(false),
	fHasLink(false),
	fConnecting(false)
{
	fInterface.SetTo(name);
	_Init();
}


InterfaceListItem::~InterfaceListItem()
{
	delete fIcon;
	delete fIconOffline;
	delete fIconPending;
	delete fIconOnline;
}


// #pragma mark - InterfaceListItem public methods


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

	rgb_color lowColor = owner->LowColor();

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

		owner->FillRect(bounds);
	}

	BBitmap* stateIcon = _StateIcon();
	const int32 stateIconWidth = stateIcon->Bounds().IntegerWidth() + 1;
	const char* stateText = _StateText();

	// Set the initial bounds of item contents
	BPoint iconPoint = bounds.LeftTop()
		+ BPoint(be_control_look->DefaultLabelSpacing(), 2);
	BPoint statePoint = bounds.RightTop() + BPoint(0, fFirstLineOffset)
		- BPoint(be_plain_font->StringWidth(stateText)
			+ be_control_look->DefaultLabelSpacing(), 0);
	BPoint namePoint = bounds.LeftTop()
		+ BPoint(stateIconWidth	+ (be_control_look->DefaultLabelSpacing() * 2),
			fFirstLineOffset);

	if (fDisabled) {
		owner->SetDrawingMode(B_OP_ALPHA);
		owner->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_OVERLAY);
		owner->SetHighColor(0, 0, 0, 32);
	} else
		owner->SetDrawingMode(B_OP_OVER);

	owner->DrawBitmapAsync(fIcon, iconPoint);
	owner->DrawBitmapAsync(stateIcon, iconPoint);

	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_bold_font);

	owner->DrawString(fDeviceName, namePoint);
	owner->SetFont(be_plain_font);
	owner->DrawString(stateText, statePoint);

	BPoint linePoint = bounds.LeftTop()
		+ BPoint(stateIconWidth + (be_control_look->DefaultLabelSpacing() * 2),
		fFirstLineOffset + fLineOffset);
	owner->DrawString(fSubtitle, linePoint);

	owner->PopState();
}


void
InterfaceListItem::Update(BView* owner, const BFont* font)
{
	BListItem::Update(owner, font);
	font_height height;
	font->GetHeight(&height);

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

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

	_UpdateState();

	SetWidth(fIcon->Bounds().Width() + 36
		+ be_control_look->DefaultLabelSpacing()
		+ be_bold_font->StringWidth(fDeviceName.String())
		+ owner->StringWidth(_StateText()));
	SetHeight(std::max(2 * lineHeight + 4, fIcon->Bounds().Height() + 4));
		// either to the text height or icon height, whichever is taller
}


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


// #pragma mark - InterfaceListItem private methods


void
InterfaceListItem::_Init()
{
	switch (fType) {
		case B_NETWORK_INTERFACE_TYPE_WIFI:
			_PopulateBitmaps("wifi");
			break;
		case B_NETWORK_INTERFACE_TYPE_ETHERNET:
			_PopulateBitmaps("ether");
			break;
		case B_NETWORK_INTERFACE_TYPE_VPN:
			_PopulateBitmaps("vpn");
			break;
		case B_NETWORK_INTERFACE_TYPE_DIAL_UP:
			_PopulateBitmaps("dialup");
			break;
		default:
			_PopulateBitmaps(NULL);
			break;
	}
}


void
InterfaceListItem::_PopulateBitmaps(const char* mediaType)
{
	const uint8* interfaceHVIF;
	const uint8* offlineHVIF;
	const uint8* pendingHVIF;
	const uint8* onlineHVIF;

	BBitmap* interfaceBitmap = NULL;
	BBitmap* offlineBitmap = NULL;
	BBitmap* pendingBitmap = NULL;
	BBitmap* onlineBitmap = NULL;

	BResources* resources = BApplication::AppResources();

	size_t iconDataSize;

	// Try specific interface icon?
	interfaceHVIF = (const uint8*)resources->LoadResource(
		B_VECTOR_ICON_TYPE, Name(), &iconDataSize);

	if (interfaceHVIF == NULL && mediaType != NULL)
		// Not found, try interface media type?
		interfaceHVIF = (const uint8*)resources->LoadResource(
			B_VECTOR_ICON_TYPE, mediaType, &iconDataSize);
	if (interfaceHVIF == NULL)
		// Not found, try default interface icon?
		interfaceHVIF = (const uint8*)resources->LoadResource(
			B_VECTOR_ICON_TYPE, "ether", &iconDataSize);

	const BSize iconSize = be_control_look->ComposeIconSize(B_LARGE_ICON);
	if (interfaceHVIF != NULL) {
		// Now build the bitmap
		interfaceBitmap = new(std::nothrow) BBitmap(
			BRect(BPoint(0, 0), iconSize), 0, B_RGBA32);
		if (BIconUtils::GetVectorIcon(interfaceHVIF,
				iconDataSize, interfaceBitmap) == B_OK)
			fIcon = interfaceBitmap;
		else
			delete interfaceBitmap;
	}

	// Load possible state icons
	offlineHVIF = (const uint8*)resources->LoadResource(
		B_VECTOR_ICON_TYPE, "offline", &iconDataSize);

	if (offlineHVIF != NULL) {
		offlineBitmap = new(std::nothrow) BBitmap(
			BRect(BPoint(0, 0), iconSize), 0, B_RGBA32);
		if (BIconUtils::GetVectorIcon(offlineHVIF,
				iconDataSize, offlineBitmap) == B_OK)
			fIconOffline = offlineBitmap;
		else
			delete offlineBitmap;
	}

	pendingHVIF = (const uint8*)resources->LoadResource(
		B_VECTOR_ICON_TYPE, "pending", &iconDataSize);

	if (pendingHVIF != NULL) {
		pendingBitmap = new(std::nothrow) BBitmap(
			BRect(BPoint(0, 0), iconSize), 0, B_RGBA32);
		if (BIconUtils::GetVectorIcon(pendingHVIF,
				iconDataSize, pendingBitmap) == B_OK)
			fIconPending = pendingBitmap;
		else
			delete pendingBitmap;
	}

	onlineHVIF = (const uint8*)resources->LoadResource(
		B_VECTOR_ICON_TYPE, "online", &iconDataSize);

	if (onlineHVIF != NULL) {
		onlineBitmap = new(std::nothrow) BBitmap(
			BRect(BPoint(0, 0), iconSize), 0, B_RGBA32);
		if (BIconUtils::GetVectorIcon(onlineHVIF,
				iconDataSize, onlineBitmap) == B_OK)
			fIconOnline = onlineBitmap;
		else
			delete onlineBitmap;
	}
}


void
InterfaceListItem::_UpdateState()
{
	fDeviceName = Name();
	fDeviceName.RemoveFirst("/dev/net/");

	fDisabled = (fInterface.Flags() & IFF_UP) == 0;
	fHasLink = fInterface.HasLink();
	fConnecting = (fInterface.Flags() & IFF_CONFIGURING) != 0;

	switch (fType) {
		case B_NETWORK_INTERFACE_TYPE_WIFI:
			fSubtitle = B_TRANSLATE("Wireless device");
			break;
		case B_NETWORK_INTERFACE_TYPE_ETHERNET:
			fSubtitle = B_TRANSLATE("Ethernet device");
			break;
		case B_NETWORK_INTERFACE_TYPE_DIAL_UP:
			fSubtitle = B_TRANSLATE("Dial-up connection");
			fDisabled = false;
			break;
		case B_NETWORK_INTERFACE_TYPE_VPN:
			fSubtitle = B_TRANSLATE("VPN connection");
			fDisabled = false;
			break;
		default:
			fSubtitle = "";
	}
}


BBitmap*
InterfaceListItem::_StateIcon() const
{
	if (fDisabled)
		return fIconOffline;
	if (!fHasLink)
		return fIconOffline;
	// TODO!
//	} else if ((fSettings->IPAddr(AF_INET).IsEmpty()
//		&& fSettings->IPAddr(AF_INET6).IsEmpty())
//		&& (fSettings->AutoConfigure(AF_INET)
//		|| fSettings->AutoConfigure(AF_INET6))) {
//		interfaceState = "connecting" B_UTF8_ELLIPSIS;
//		stateIcon = fIconPending;

	return fIconOnline;
}


const char*
InterfaceListItem::_StateText() const
{
	if (fDisabled)
		return B_TRANSLATE("disabled");

	if (!fInterface.HasLink()) {
		switch (fType) {
			case B_NETWORK_INTERFACE_TYPE_VPN:
			case B_NETWORK_INTERFACE_TYPE_DIAL_UP:
				return B_TRANSLATE("disconnected");
			default:
				return B_TRANSLATE("no link");
		}
	}

	// TODO!
//	} else if ((fSettings->IPAddr(AF_INET).IsEmpty()
//		&& fSettings->IPAddr(AF_INET6).IsEmpty())
//		&& (fSettings->AutoConfigure(AF_INET)
//		|| fSettings->AutoConfigure(AF_INET6))) {
//		interfaceState = "connecting" B_UTF8_ELLIPSIS;
//		stateIcon = fIconPending;

	return B_TRANSLATE("connected");
}