/*
 * Copyright 2001 Werner Freytag - please read to the LICENSE file
 *
 * Copyright 2002-2006, Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved.
 *
 */

#include "ColorField.h"

#include <stdio.h>

#include <Bitmap.h>
#include <ControlLook.h>
#include <LayoutUtils.h>
#include <OS.h>
#include <Region.h>
#include <Window.h>

#include "support_ui.h"

#include "rgb_hsv.h"

#define round(x) (int)(x +.5)

enum {
	MSG_UPDATE			= 'Updt',
};

#define MAX_X 255
#define MAX_Y 255

// constructor
ColorField::ColorField(BPoint offsetPoint, SelectedColorMode mode,
	float fixedValue, orientation orient, border_style border)
	: BControl(BRect(0.0, 0.0, MAX_X + 4.0, MAX_Y + 4.0)
			.OffsetToCopy(offsetPoint),
		"ColorField", "", new BMessage(MSG_COLOR_FIELD),
		B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_FRAME_EVENTS)
{
	_Init(mode, fixedValue, orient, border);
	FrameResized(Bounds().Width(), Bounds().Height());
}

// constructor
ColorField::ColorField(SelectedColorMode mode, float fixedValue,
	orientation orient, border_style border)
	: BControl("ColorField", "", new BMessage(MSG_COLOR_FIELD),
		B_WILL_DRAW | B_FRAME_EVENTS)
{
	_Init(mode, fixedValue, orient, border);
}

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

// MinSize
BSize
ColorField::MinSize()
{
	BSize minSize;
	if (fOrientation == B_VERTICAL)
		minSize = BSize(4 + MAX_X / 17, 4 + MAX_Y / 5);
	else
		minSize = BSize(4 + MAX_X / 5, 4 + MAX_Y / 17);

	return BLayoutUtils::ComposeSize(ExplicitMinSize(), minSize);
}

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

// MaxSize
BSize
ColorField::MaxSize()
{
	BSize maxSize(4 + MAX_X, 4 + MAX_Y);
	return BLayoutUtils::ComposeSize(ExplicitMaxSize(), maxSize);
//	return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
//		BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
}

// Invoke
status_t
ColorField::Invoke(BMessage* message)
{
	if (message == NULL)
		message = Message();

	if (message == NULL)
		return BControl::Invoke(message);

	message->RemoveName("value");

	float v1 = 0;
	float v2 = 0;

	switch (fMode) {
		case R_SELECTED:
		case G_SELECTED:
		case B_SELECTED:
			v1 = fMarkerPosition.x / Width();
			v2 = 1.0 - fMarkerPosition.y / Height();
			break;

		case H_SELECTED:
			if (fOrientation == B_VERTICAL) {
				v1 = fMarkerPosition.x / Width();
				v2 = 1.0 - fMarkerPosition.y / Height();
			} else {
				v1 = fMarkerPosition.y / Height();
				v2 = 1.0 - fMarkerPosition.x / Width();
			}
			break;

		case S_SELECTED:
		case V_SELECTED:
			v1 = fMarkerPosition.x / Width() * 6.0;
			v2 = 1.0 - fMarkerPosition.y / Height();
			break;

	}

	message->AddFloat("value", v1);
	message->AddFloat("value", v2);

	return BControl::Invoke(message);
}

// AttachedToWindow
void
ColorField::AttachedToWindow()
{
}

// Draw
void
ColorField::Draw(BRect updateRect)
{
	if (fBitmapDirty && fBitmap != NULL) {
		_FillBitmap(fBitmap, fMode, fFixedValue, fOrientation);
		fBitmapDirty = false;
	}

	BRect bounds = Bounds();

	// Frame
	if (fBorderStyle == B_FANCY_BORDER) {
		rgb_color color = LowColor();
		be_control_look->DrawTextControlBorder(this, bounds, updateRect,
			color);
		BRegion region(bounds);
		ConstrainClippingRegion(&region);
	}

	// Color field fill
	if (fBitmap != NULL)
		DrawBitmap(fBitmap, bounds.LeftTop());
	else {
		SetHighColor(255, 0, 0);
		FillRect(bounds);
	}

	// Marker
	SetHighColor(0, 0, 0);
	StrokeEllipse(fMarkerPosition + bounds.LeftTop(), 5.0, 5.0);
	SetHighColor(255.0, 255.0, 255.0);
	StrokeEllipse(fMarkerPosition + bounds.LeftTop(), 4.0, 4.0);
}

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

// MouseDown
void
ColorField::MouseDown(BPoint where)
{
	fMouseDown = true;
	SetMouseEventMask(B_POINTER_EVENTS,
		B_SUSPEND_VIEW_FOCUS | B_LOCK_WINDOW_FOCUS);
	PositionMarkerAt(where);

	if (Message() != NULL) {
		BMessage message(*Message());
		message.AddBool("begin", true);
		Invoke(&message);
	} else
		Invoke();
}

// MouseUp
void
ColorField::MouseUp(BPoint where)
{
	fMouseDown = false;
}

// MouseMoved
void
ColorField::MouseMoved(BPoint where, uint32 transit,
	const BMessage* dragMessage)
{
	if (dragMessage != NULL || !fMouseDown ) {
		BView::MouseMoved(where, transit, dragMessage);
		return;
	}

	PositionMarkerAt(where);
	Invoke();
}

// SetModeAndValue
void
ColorField::SetModeAndValue(SelectedColorMode mode, float fixedValue)
{
	float R(0), G(0), B(0);
	float H(0), S(0), V(0);

	float width = Width();
	float height = Height();

	switch (fMode) {

		case R_SELECTED: {
			R = fFixedValue * 255;
			G = round(fMarkerPosition.x / width * 255.0);
			B = round(255.0 - fMarkerPosition.y / height * 255.0);
		}; break;

		case G_SELECTED: {
			R = round(fMarkerPosition.x / width * 255.0);
			G = fFixedValue * 255;
			B = round(255.0 - fMarkerPosition.y / height * 255.0);
		}; break;

		case B_SELECTED: {
			R = round(fMarkerPosition.x / width * 255.0);
			G = round(255.0 - fMarkerPosition.y / height * 255.0);
			B = fFixedValue * 255;
		}; break;

		case H_SELECTED: {
			H = fFixedValue;
			S = fMarkerPosition.x / width;
			V = 1.0 - fMarkerPosition.y / height;
		}; break;

		case S_SELECTED: {
			H = fMarkerPosition.x / width * 6.0;
			S = fFixedValue;
			V = 1.0 - fMarkerPosition.y / height;
		}; break;

		case V_SELECTED: {
			H = fMarkerPosition.x / width * 6.0;
			S = 1.0 - fMarkerPosition.y / height;
			V = fFixedValue;
		}; break;
	}

	if (fMode & (H_SELECTED | S_SELECTED | V_SELECTED)) {
		HSV_to_RGB(H, S, V, R, G, B);
		R *= 255.0; G *= 255.0; B *= 255.0;
	}

	rgb_color color = { (uint8)round(R), (uint8)round(G), (uint8)round(B), 
		255 };

	if (fFixedValue != fixedValue || fMode != mode) {
		fFixedValue = fixedValue;
		fMode = mode;

		_Update();
	}

	SetMarkerToColor(color);
}

// SetFixedValue
void
ColorField::SetFixedValue(float fixedValue)
{
	if (fFixedValue != fixedValue) {
		fFixedValue = fixedValue;
		_Update();
	}
}

// SetMarkerToColor
void
ColorField::SetMarkerToColor(rgb_color color)
{
	float h, s, v;
	RGB_to_HSV(color.red / 255.0, color.green / 255.0, color.blue / 255.0,
		h, s, v );

	fLastMarkerPosition = fMarkerPosition;

	float width = Width();
	float height = Height();

	switch (fMode) {
		case R_SELECTED:
			fMarkerPosition = BPoint(color.green / 255.0 * width,
				(255.0 - color.blue) / 255.0 * height);
			break;

		case G_SELECTED:
			fMarkerPosition = BPoint(color.red / 255.0 * width,
				(255.0 - color.blue) / 255.0 * height);
			break;

		case B_SELECTED:
			fMarkerPosition = BPoint(color.red / 255.0 * width,
				(255.0 - color.green) / 255.0 * height);
			break;

		case H_SELECTED:
			if (fOrientation == B_VERTICAL)
				fMarkerPosition = BPoint(s * width, height - v * height);
			else
				fMarkerPosition = BPoint(width - v * width, s * height);
			break;

		case S_SELECTED:
			fMarkerPosition = BPoint(h / 6.0 * width, height - v * height);
			break;

		case V_SELECTED:
			fMarkerPosition = BPoint( h / 6.0 * width, height - s * height);
			break;
	}

	Invalidate();
}

// PositionMarkerAt
void
ColorField::PositionMarkerAt(BPoint where)
{
	BRect rect = _BitmapRect();
	where.ConstrainTo(rect);
	where -= rect.LeftTop();

	fLastMarkerPosition = fMarkerPosition;
	fMarkerPosition = where;
	Invalidate();
}

// Width
float
ColorField::Width() const
{
	return _BitmapRect().IntegerWidth() + 1;
}

// Height
float
ColorField::Height() const
{
	return _BitmapRect().IntegerHeight() + 1;
}

// set_bits
static inline void
set_bits(uint8* bits, uint8 r, uint8 g, uint8 b)
{
	bits[0] = b;
	bits[1] = g;
	bits[2] = r;
	bits[3] = 255;
}

// _Init
void
ColorField::_Init(SelectedColorMode mode, float fixedValue,
	orientation orient, border_style border)
{
	fMode = mode;
	fFixedValue = fixedValue;
	fOrientation = orient;
	fBorderStyle = border;

	fMarkerPosition = BPoint(0.0, 0.0);
	fLastMarkerPosition = BPoint(-1.0, -1.0);
	fMouseDown = false;

	fBitmap = NULL;
	fBitmapDirty = true;

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

// _AllocBitmap
void
ColorField::_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);

	fBitmapDirty = true;
}

// _Update
void
ColorField::_Update()
{
	fBitmapDirty = true;
	Invalidate();
}

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

// _FillBitmap
void
ColorField::_FillBitmap(BBitmap* bitmap, SelectedColorMode mode,
	float fixedValue, orientation orient) const
{
	int32 width = bitmap->Bounds().IntegerWidth();
	int32 height = bitmap->Bounds().IntegerHeight();
	uint32 bpr = bitmap->BytesPerRow();

//bigtime_t now = system_time();
	uint8* bits = (uint8*)bitmap->Bits();

	float r = 0;
	float g = 0;
	float b = 0;
	float h;
	float s;
	float v;

	switch (mode) {
		case R_SELECTED:
			r = round(fixedValue * 255);
			for (int y = height; y >= 0; y--) {
				uint8* bitsHandle = bits;
				b = y * 255 / height;
				for (int32 x = 0; x <= width; x++) {
					g = x * 255 / width;
					set_bits(bitsHandle, (uint8)r, (uint8)g, (uint8)b);
					bitsHandle += 4;
				}
				bits += bpr;
			}
			break;

		case G_SELECTED:
			g = round(fixedValue * 255);
			for (int y = height; y >= 0; y--) {
				uint8* bitsHandle = bits;
				b = y * 255 / height;
				for (int x = 0; x <= width; x++) {
					r = x * 255 / width;
					set_bits(bitsHandle, (uint8)r, (uint8)g, (uint8)b);
					bitsHandle += 4;
				}
				bits += bpr;
			}
			break;

		case B_SELECTED:
			b = round(fixedValue * 255);
			for (int y = height; y >= 0; y--) {
				uint8* bitsHandle = bits;
				g = y * 255 / height;
				for (int x = 0; x <= width; ++x) {
					r = x * 255 / width;
					set_bits(bitsHandle, (uint8)r, (uint8)g, (uint8)b);
					bitsHandle += 4;
				}
				bits += bpr;
			}
			break;

		case H_SELECTED:
			h = fixedValue;
			if (orient == B_VERTICAL) {
				for (int y = 0; y <= height; ++y) {
					v = (float)(height - y) / height;
					uint8* bitsHandle = bits;
					for (int x = 0; x <= width; ++x) {
						s = (float)x / width;
						HSV_to_RGB(h, s, v, r, g, b);
						set_bits(bitsHandle,
							round(r * 255.0),
							round(g * 255.0),
							round(b * 255.0));
						bitsHandle += 4;
					}
					bits += bpr;
				}
			} else {
				for (int y = 0; y <= height; ++y) {
					s = (float)y / height;
					uint8* bitsHandle = bits;
					for (int x = 0; x <= width; ++x) {
						v = (float)(width - x) / width;
						HSV_to_RGB(h, s, v, r, g, b);
						set_bits(bitsHandle,
							round(r * 255.0),
							round(g * 255.0),
							round(b * 255.0));
						bitsHandle += 4;
					}
					bits += bpr;
				}
			}
			break;

		case S_SELECTED:
			s = fixedValue;
			for (int y = 0; y <= height; ++y) {
				v = (float)(height - y) / height;
				uint8* bitsHandle = bits;
				for (int x = 0; x <= width; ++x) {
					h = 6.0 / width * x;
					HSV_to_RGB(h, s, v, r, g, b);
					set_bits(bitsHandle,
						round(r * 255.0),
						round(g * 255.0),
						round(b * 255.0));
					bitsHandle += 4;
				}
				bits += bpr;
			}
			break;

		case V_SELECTED:
			v = fixedValue;
			for (int y = 0; y <= height; ++y) {
				s = (float)(height - y) / height;
				uint8* bitsHandle = bits;
				for (int x = 0; x <= width; ++x) {
					h = 6.0 / width * x;
					HSV_to_RGB(h, s, v, r, g, b);
					set_bits(bitsHandle,
						round(r * 255.0),
						round(g * 255.0),
						round(b * 255.0));
					bitsHandle += 4;
				}
				bits += bpr;
			}
			break;
	}
}