/*
 * Copyright 2006-2012 Stephan Aßmus <superstippi@gmx.de>
 * Distributed under the terms of the MIT License.
 */

#include "AlphaSlider.h"

#include <stdio.h>
#include <string.h>

#include <AppDefs.h>
#include <Bitmap.h>
#include <ControlLook.h>
#include <LayoutUtils.h>
#include <Message.h>
#include <Window.h>

#include "ui_defines.h"

// constructor
AlphaSlider::AlphaSlider(orientation dir, BMessage* message,
	border_style border)
	: BControl("alpha slider", NULL, message,
		B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE)
	, fBitmap(NULL)
	, fColor(kBlack)
	, fDragging(false)
	, fOrientation(dir)
	, fBorderStyle(border)
{
	FrameResized(Bounds().Width(), Bounds().Height());

	SetViewColor(B_TRANSPARENT_COLOR);
	SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));

	SetValue(255);
}

// destructor
AlphaSlider::~AlphaSlider()
{
	delete fBitmap;
}

// WindowActivated
void
AlphaSlider::WindowActivated(bool active)
{
	if (IsFocus())
		Invalidate();
}

// MakeFocus
void
AlphaSlider::MakeFocus(bool focus)
{
	if (focus != IsFocus()) {
		BControl::MakeFocus(focus);
		Invalidate();
	}
}

// MinSize
BSize
AlphaSlider::MinSize()
{
	BSize minSize;
	if (fOrientation == B_HORIZONTAL)
		minSize = BSize(255 + 4, 7 + 4);
	else
		minSize = BSize(7 + 4, 255 + 4);
	return BLayoutUtils::ComposeSize(ExplicitMinSize(), minSize);
}

// PreferredSize
BSize
AlphaSlider::PreferredSize()
{
	return BLayoutUtils::ComposeSize(ExplicitPreferredSize(), MinSize());
}

// MaxSize
BSize
AlphaSlider::MaxSize()
{
	BSize minSize;
	if (fOrientation == B_HORIZONTAL)
		minSize = BSize(B_SIZE_UNLIMITED, 16 + 4);
	else
		minSize = BSize(16 + 4, B_SIZE_UNLIMITED);
	return BLayoutUtils::ComposeSize(ExplicitMinSize(), minSize);
}

// MouseDown
void
AlphaSlider::MouseDown(BPoint where)
{
	if (!IsEnabled())
		return;

//	if (!IsFocus())
//		MakeFocus(true);

	fDragging = true;
	SetValue(_ValueFor(where));

	SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
}

// MouseUp
void
AlphaSlider::MouseUp(BPoint where)
{
	fDragging = false;
}

// MouseMoved
void
AlphaSlider::MouseMoved(BPoint where, uint32 transit,
	const BMessage* dragMessage)
{
	if (!IsEnabled() || !fDragging)
		return;

	SetValue(_ValueFor(where));
}

// KeyDown
void
AlphaSlider::KeyDown(const char* bytes, int32 numBytes)
{
	if (!IsEnabled() || numBytes <= 0) {
		BControl::KeyDown(bytes, numBytes);
		return;
	}

	switch (bytes[0]) {
		case B_HOME:
			SetValue(0);
			break;
		case B_END:
			SetValue(255);
			break;

		case B_LEFT_ARROW:
		case B_UP_ARROW:
			SetValue(max_c(0, Value() - 1));
			break;
		case B_RIGHT_ARROW:
		case B_DOWN_ARROW:
			SetValue(min_c(255, Value() + 1));
			break;

		default:
			BControl::KeyDown(bytes, numBytes);
			break;
	}
}

// Draw
void
AlphaSlider::Draw(BRect updateRect)
{
	BRect b = Bounds();
	bool isFocus = IsFocus() && Window()->IsActive();

	if (fBorderStyle == B_FANCY_BORDER) {
		rgb_color bg = LowColor();
		uint32 flags = 0;

		if (!IsEnabled())
			flags |= BControlLook::B_DISABLED;
		if (isFocus)
			flags |= BControlLook::B_FOCUSED;

		be_control_look->DrawTextControlBorder(this, b, updateRect, bg, flags);
	}

	DrawBitmap(fBitmap, b.LeftTop());

	// value marker
	if (fOrientation == B_HORIZONTAL) {
		float pos = floorf(b.left + Value() * b.Width() / 255.0 + 0.5);

		if (pos - 2 >= b.left) {
			SetHighColor(kWhite);
			StrokeLine(BPoint(pos - 2, b.top), BPoint(pos - 2, b.bottom));
		}
		if (pos - 1 >= b.left) {
			SetHighColor(kBlack);
			StrokeLine(BPoint(pos - 1, b.top), BPoint(pos - 1, b.bottom));
		}
		if (pos + 1 <= b.right) {
			SetHighColor(kBlack);
			StrokeLine(BPoint(pos + 1, b.top), BPoint(pos + 1, b.bottom));
		}
		if (pos + 2 <= b.right) {
			SetHighColor(kWhite);
			StrokeLine(BPoint(pos + 2, b.top), BPoint(pos + 2, b.bottom));
		}
	} else {
		float pos = floorf(b.top + Value() * b.Height() / 255.0 + 0.5);

		if (pos - 2 >= b.top) {
			SetHighColor(kWhite);
			StrokeLine(BPoint(b.left, pos - 2), BPoint(b.right, pos - 2));
		}
		if (pos - 1 >= b.top) {
			SetHighColor(kBlack);
			StrokeLine(BPoint(b.left, pos - 1), BPoint(b.right, pos - 1));
		}
		if (pos + 1 <= b.bottom) {
			SetHighColor(kBlack);
			StrokeLine(BPoint(b.left, pos + 1), BPoint(b.right, pos + 1));
		}
		if (pos + 2 <= b.bottom) {
			SetHighColor(kWhite);
			StrokeLine(BPoint(b.left, pos + 2), BPoint(b.right, pos + 2));
		}
	}
}

// FrameResized
void
AlphaSlider::FrameResized(float width, float height)
{
	BRect r = _BitmapRect();
	_AllocBitmap(r.IntegerWidth() + 1, r.IntegerHeight() + 1);
	_UpdateColors();
	Invalidate();

}

// SetValue
void
AlphaSlider::SetValue(int32 value)
{
	if (value == Value())
		return;

	Invoke(Message());
	BControl::SetValue(value);
}

// SetEnabled
void
AlphaSlider::SetEnabled(bool enabled)
{
	if (enabled == IsEnabled())
		return;

	BControl::SetEnabled(enabled);

	_UpdateColors();
	Invalidate();
}

// #pragma mark -

// SetColor
void
AlphaSlider::SetColor(const rgb_color& color)
{
	if ((uint32&)fColor == (uint32&)color)
		return;

	fColor = color;

	_UpdateColors();
	Invalidate();
}

// #pragma mark -

// blend_colors
inline void
blend_colors(uint8* d, uint8 alpha, uint8 c1, uint8 c2, uint8 c3)
{
	if (alpha > 0) {
		if (alpha == 255) {
			d[0] = c1;
			d[1] = c2;
			d[2] = c3;
		} else {
			d[0] += (uint8)(((c1 - d[0]) * alpha) >> 8);
			d[1] += (uint8)(((c2 - d[1]) * alpha) >> 8);
			d[2] += (uint8)(((c3 - d[2]) * alpha) >> 8);
		}
	}
}

// _UpdateColors
void
AlphaSlider::_UpdateColors()
{
	if (fBitmap == NULL || !fBitmap->IsValid())
		return;

	// fill in top row with alpha gradient
	uint8* topRow = (uint8*)fBitmap->Bits();
	uint32 width = fBitmap->Bounds().IntegerWidth() + 1;

	uint8* p = topRow;
	rgb_color color = fColor;
	if (!IsEnabled()) {
		// blend low color and color to give disabled look
		rgb_color bg = LowColor();
		color.red = (uint8)(((uint32)bg.red + color.red) / 2);
		color.green = (uint8)(((uint32)bg.green + color.green) / 2);
		color.blue = (uint8)(((uint32)bg.blue + color.blue) / 2);
	}
	for (uint32 x = 0; x < width; x++) {
		p[0] = color.blue;
		p[1] = color.green;
		p[2] = color.red;
		p[3] = x * 255 / width;
		p += 4;
	}
	// copy top row to rest of bitmap
	uint32 height = fBitmap->Bounds().IntegerHeight() + 1;
	uint32 bpr = fBitmap->BytesPerRow();
	uint8* dstRow = topRow + bpr;
	for (uint32 i = 1; i < height; i++) {
		memcpy(dstRow, topRow, bpr);
		dstRow += bpr;
	}
	// post process bitmap to underlay it with a pattern to visualize alpha
	uint8* row = topRow;
	for (uint32 i = 0; i < height; i++) {
		uint8* p = row;
		for (uint32 x = 0; x < width; x++) {
			uint8 alpha = p[3];
			if (alpha < 255) {
				p[3] = 255;
				alpha = 255 - alpha;
				if (x % 8 >= 4) {
					if (i % 8 >= 4) {
						blend_colors(p, alpha,
									 kAlphaLow.blue,
									 kAlphaLow.green,
									 kAlphaLow.red);
					} else {
						blend_colors(p, alpha,
									 kAlphaHigh.blue,
									 kAlphaHigh.green,
									 kAlphaHigh.red);
					}
				} else {
					if (i % 8 >= 4) {
						blend_colors(p, alpha,
									 kAlphaHigh.blue,
									 kAlphaHigh.green,
									 kAlphaHigh.red);
					} else {
						blend_colors(p, alpha,
									 kAlphaLow.blue,
									 kAlphaLow.green,
									 kAlphaLow.red);
					}
				}
			}
			p += 4;
		}
		row += bpr;
	}
}

// _AllocBitmap
void
AlphaSlider::_AllocBitmap(int32 width, int32 height)
{
	if (width < 2 || height < 2)
		return;

	delete fBitmap;
	fBitmap = new BBitmap(BRect(0, 0, width - 1, height - 1), 0, B_RGB32);
}

// _BitmapRect
BRect
AlphaSlider::_BitmapRect() const
{
	BRect r = Bounds();
	if (fBorderStyle == B_FANCY_BORDER)
		r.InsetBy(2, 2);
	return r;
}

// _ValueFor
int32
AlphaSlider::_ValueFor(BPoint where) const
{
	BRect r = _BitmapRect();

	int32 value;
	if (fOrientation == B_HORIZONTAL)
		value = (int32)(255 * (where.x - r.left) / r.Width() + 0.5);
	else
		value = (int32)(255 * (where.y - r.top) / r.Height() + 0.5);

	value = max_c(0, value);
	value = min_c(255, value);

	return value;
}