/*
 * Copyright 2001-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus, superstippi@gmx.de
 *		DarkWyrm, bpmagic@columbus.rr.com
 *		John Scipione, jscipione@gmail.com
 *		Clemens Zeidler, haiku@clemens-zeidler.de
 */


/*! Decorator resembling BeOS R5 */


#include "BeDecorator.h"

#include <algorithm>
#include <cmath>
#include <new>
#include <stdio.h>

#include <WindowPrivate.h>

#include <Autolock.h>
#include <Debug.h>
#include <GradientLinear.h>
#include <Rect.h>
#include <Region.h>
#include <View.h>

#include "BitmapDrawingEngine.h"
#include "Desktop.h"
#include "DesktopSettings.h"
#include "DrawingEngine.h"
#include "DrawState.h"
#include "FontManager.h"
#include "PatternHandler.h"
#include "RGBColor.h"
#include "ServerBitmap.h"


//#define DEBUG_DECORATOR
#ifdef DEBUG_DECORATOR
#	define STRACE(x) printf x
#else
#	define STRACE(x) ;
#endif


static const float kBorderResizeLength = 22.0;
static const float kResizeKnobSize = 18.0;


static const unsigned char f = 0xff; // way to write 0xff shorter

static const unsigned char kInnerShadowBits[] = {
	f, f, f, f, f, f, f, f, f, 0,
	f, f, f, f, f, f, 0, f, 0, f,
	f, f, f, f, f, 0, f, 0, f, 0,
	f, f, f, f, 0, f, 0, 0, 0, 0,
	f, f, f, 0, f, 0, 0, 0, 0, 0,
	f, f, 0, f, 0, 0, 0, 0, 0, 0,
	f, 0, f, 0, 0, 0, 0, 0, 0, 0,
	f, f, 0, 0, 0, 0, 0, 0, 0, 0,
	f, 0, f, 0, 0, 0, 0, 0, 0, 0,
	0, f, 0, 0, 0, 0, 0, 0, 0, 0
};

static const unsigned char kOuterShadowBits[] = {
	f, f, f, f, f, f, f, f, f, f,
	f, f, f, f, f, f, f, f, f, f,
	f, f, f, f, f, f, f, f, f, f,
	f, f, f, f, f, f, f, f, f, f,
	f, f, f, f, f, f, f, f, f, 0,
	f, f, f, f, f, f, f, 0, 0, 0,
	f, f, f, f, f, f, 0, f, 0, 0,
	f, f, f, f, f, 0, f, 0, 0, 0,
	f, f, f, f, f, 0, 0, 0, 0, 0,
	f, f, f, f, 0, 0, 0, 0, 0, 0
};

static const unsigned char kBigInnerShadowBits[] = {
	f, f, f, f, f, f, f,
	f, f, f, f, f, f, 0,
	f, f, f, f, f, 0, 0,
	f, f, f, f, 0, f, 0,
	f, f, f, 0, f, 0, 0,
	f, f, 0, f, 0, 0, 0,
	f, 0, 0, 0, 0, 0, 0
};

static const unsigned char kBigOuterShadowBits[] = {
	f, f, f, f, f, f, f,
	f, f, f, f, f, f, 0,
	f, f, f, f, f, f, 0,
	f, f, f, f, f, f, 0,
	f, f, f, f, f, f, 0,
	f, f, f, f, f, f, 0,
	f, 0, 0, 0, 0, 0, 0
};

static const unsigned char kSmallInnerShadowBits[] = {
	f, f, f, 0, 0,
	f, f, 0, f, 0,
	f, 0, f, 0, 0,
	0, f, 0, 0, 0,
	0, 0, 0, 0, 0
};

static const unsigned char kSmallOuterShadowBits[] = {
	f, f, f, f, f,
	f, f, f, f, f,
	f, f, f, f, f,
	f, f, f, f, 0,
	f, f, 0, 0, 0
};

static const unsigned char kGlintBits[] = {
	0, f, 0,
	f, 0, f,
	0, f, f
};


//     #pragma mark - BeDecorAddOn


BeDecorAddOn::BeDecorAddOn(image_id id, const char* name)
	:
	DecorAddOn(id, name)
{
}


Decorator*
BeDecorAddOn::_AllocateDecorator(DesktopSettings& settings, BRect rect,
	Desktop* desktop)
{
	return new (std::nothrow)BeDecorator(settings, rect, desktop);
}


//	#pragma mark - BeDecorator


// TODO: get rid of DesktopSettings here, and introduce private accessor
//	methods to the Decorator base class
BeDecorator::BeDecorator(DesktopSettings& settings, BRect rect,
	Desktop* desktop)
	:
	SATDecorator(settings, rect, desktop),
	fCStatus(B_NO_INIT)
{
	STRACE(("BeDecorator:\n"));
	STRACE(("\tFrame (%.1f,%.1f,%.1f,%.1f)\n",
		rect.left, rect.top, rect.right, rect.bottom));

	fCloseBitmap = _CreateTemporaryBitmap(BRect(0, 0, 9, 9));
	fBigZoomBitmap = _CreateTemporaryBitmap(BRect(0, 0, 6, 6));
	fSmallZoomBitmap = _CreateTemporaryBitmap(BRect(0, 0, 4, 4));
	fGlintBitmap = _CreateTemporaryBitmap(BRect(0, 0, 2, 2));
		// glint bitmap is used by close and zoom buttons

	if (fCloseBitmap == NULL || fBigZoomBitmap == NULL
		|| fSmallZoomBitmap == NULL || fGlintBitmap == NULL) {
		fCStatus = B_NO_MEMORY;
	} else
		fCStatus = B_OK;
}


BeDecorator::~BeDecorator()
{
	STRACE(("BeDecorator: ~BeDecorator()\n"));
	//delete[] fFrameColors;

	if (fCloseBitmap != NULL)
		fCloseBitmap->ReleaseReference();

	if (fBigZoomBitmap != NULL)
		fBigZoomBitmap->ReleaseReference();

	if (fSmallZoomBitmap != NULL)
		fSmallZoomBitmap->ReleaseReference();

	if (fGlintBitmap != NULL)
		fGlintBitmap->ReleaseReference();
}


// #pragma mark - Public methods


/*!	Returns the frame colors for the specified decorator component.

	The meaning of the color array elements depends on the specified component.
	For some components some array elements are unused.

	\param component The component for which to return the frame colors.
	\param highlight The highlight set for the component.
	\param colors An array of colors to be initialized by the function.
*/
void
BeDecorator::GetComponentColors(Component component, uint8 highlight,
	ComponentColors _colors, Decorator::Tab* _tab)
{
	Decorator::Tab* tab = static_cast<Decorator::Tab*>(_tab);
	switch (component) {
		case COMPONENT_TAB:
			if (highlight == HIGHLIGHT_STACK_AND_TILE) {
				_colors[COLOR_TAB_FRAME_LIGHT]
					= tint_color(fFocusFrameColor, B_DARKEN_3_TINT);
				_colors[COLOR_TAB_FRAME_DARK]
					= tint_color(fFocusFrameColor, B_DARKEN_4_TINT);
				_colors[COLOR_TAB] = tint_color(fFocusTabColor,
					B_DARKEN_1_TINT);
				_colors[COLOR_TAB_LIGHT] = tint_color(fFocusTabColorLight,
					B_DARKEN_1_TINT);
				_colors[COLOR_TAB_BEVEL] = fFocusTabColorBevel;
				_colors[COLOR_TAB_SHADOW] = fFocusTabColorShadow;
				_colors[COLOR_TAB_TEXT] = fFocusTextColor;
			} else if (tab && tab->buttonFocus) {
				_colors[COLOR_TAB_FRAME_LIGHT]
					= tint_color(fFocusFrameColor, B_DARKEN_2_TINT);
				_colors[COLOR_TAB_FRAME_DARK]
					= tint_color(fFocusFrameColor, B_DARKEN_3_TINT);
				_colors[COLOR_TAB] = fFocusTabColor;
				_colors[COLOR_TAB_LIGHT] = fFocusTabColorLight;
				_colors[COLOR_TAB_BEVEL] = fFocusTabColorBevel;
				_colors[COLOR_TAB_SHADOW] = fFocusTabColorShadow;
				_colors[COLOR_TAB_TEXT] = fFocusTextColor;
			} else {
				_colors[COLOR_TAB_FRAME_LIGHT]
					= tint_color(fNonFocusFrameColor, B_DARKEN_2_TINT);
				_colors[COLOR_TAB_FRAME_DARK]
					= tint_color(fNonFocusFrameColor, B_DARKEN_3_TINT);
				_colors[COLOR_TAB] = fNonFocusTabColor;
				_colors[COLOR_TAB_LIGHT] = fNonFocusTabColorLight;
				_colors[COLOR_TAB_BEVEL] = fNonFocusTabColorBevel;
				_colors[COLOR_TAB_SHADOW] = fNonFocusTabColorShadow;
				_colors[COLOR_TAB_TEXT] = fNonFocusTextColor;
			}
			break;

		case COMPONENT_CLOSE_BUTTON:
		case COMPONENT_ZOOM_BUTTON:
			if (highlight == HIGHLIGHT_STACK_AND_TILE) {
				_colors[COLOR_BUTTON] = tint_color(fFocusTabColor,
					B_DARKEN_1_TINT);
				_colors[COLOR_BUTTON_LIGHT] = tint_color(fFocusTabColorLight,
					B_DARKEN_1_TINT);
			} else if (tab && tab->buttonFocus) {
				_colors[COLOR_BUTTON] = fFocusTabColor;
				_colors[COLOR_BUTTON_LIGHT] = fFocusTabColorLight;
			} else {
				_colors[COLOR_BUTTON] = fNonFocusTabColor;
				_colors[COLOR_BUTTON_LIGHT] = fNonFocusTabColorLight;
			}
			break;

		case COMPONENT_LEFT_BORDER:
		case COMPONENT_RIGHT_BORDER:
		case COMPONENT_TOP_BORDER:
		case COMPONENT_BOTTOM_BORDER:
		case COMPONENT_RESIZE_CORNER:
		default:
		{
			rgb_color base;
			if (highlight == HIGHLIGHT_STACK_AND_TILE)
				base = tint_color(fFocusFrameColor, B_DARKEN_3_TINT);
			else if (tab && tab->buttonFocus)
				base = fFocusFrameColor;
			else
				base = fNonFocusFrameColor;

			//_colors[0].SetColor(152, 152, 152);
			//_colors[1].SetColor(255, 255, 255);
			//_colors[2].SetColor(216, 216, 216);
			//_colors[3].SetColor(136, 136, 136);
			//_colors[4].SetColor(152, 152, 152);
			//_colors[5].SetColor(96, 96, 96);

			_colors[0].red = std::max(0, base.red - 72);
			_colors[0].green = std::max(0, base.green - 72);
			_colors[0].blue = std::max(0, base.blue - 72);
			_colors[0].alpha = 255;

			_colors[1].red = std::min(255, base.red + 64);
			_colors[1].green = std::min(255, base.green  + 64);
			_colors[1].blue = std::min(255, base.blue  + 64);
			_colors[1].alpha = 255;

			_colors[2].red = std::max(0, base.red - 8);
			_colors[2].green = std::max(0, base.green - 8);
			_colors[2].blue = std::max(0, base.blue - 8);
			_colors[2].alpha = 255;

			_colors[3].red = std::max(0, base.red - 88);
			_colors[3].green = std::max(0, base.green - 88);
			_colors[3].blue = std::max(0, base.blue - 88);
			_colors[3].alpha = 255;

			_colors[4].red = std::max(0, base.red - 72);
			_colors[4].green = std::max(0, base.green - 72);
			_colors[4].blue = std::max(0, base.blue - 72);
			_colors[4].alpha = 255;

			_colors[5].red = std::max(0, base.red - 128);
			_colors[5].green = std::max(0, base.green - 128);
			_colors[5].blue = std::max(0, base.blue - 128);
			_colors[5].alpha = 255;

			// for the resize-border highlight dye everything bluish.
			if (highlight == HIGHLIGHT_RESIZE_BORDER) {
				for (int32 i = 0; i < 6; i++) {
					_colors[i].red = std::max((int)_colors[i].red - 80, 0);
					_colors[i].green = std::max((int)_colors[i].green - 80, 0);
					_colors[i].blue = 255;
				}
			}
			break;
		}
	}
}


// #pragma mark - Protected methods


void
BeDecorator::_DrawFrame(BRect invalid)
{
	STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
		invalid.right, invalid.bottom));

	// NOTE: the DrawingEngine needs to be locked for the entire
	// time for the clipping to stay valid for this decorator

	if (fTopTab->look == B_NO_BORDER_WINDOW_LOOK)
		return;

	if (fBorderWidth <= 0)
		return;

	// Draw the border frame
	BRect r = BRect(fTopBorder.LeftTop(), fBottomBorder.RightBottom());
	switch ((int)fTopTab->look) {
		case B_TITLED_WINDOW_LOOK:
		case B_DOCUMENT_WINDOW_LOOK:
		case B_MODAL_WINDOW_LOOK:
		{
			// top
			if (invalid.Intersects(fTopBorder)) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_TOP_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 5; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.top + i),
						BPoint(r.right - i, r.top + i), colors[i]);
				}
				if (fTitleBarRect.IsValid()) {
					// grey along the bottom of the tab
					// (overwrites "white" from frame)
					fDrawingEngine->StrokeLine(
						BPoint(fTitleBarRect.left + 2,
							fTitleBarRect.bottom + 1),
						BPoint(fTitleBarRect.right - 2,
							fTitleBarRect.bottom + 1),
						colors[2]);
				}
			}
			// left
			if (invalid.Intersects(fLeftBorder.InsetByCopy(0, -fBorderWidth))) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_LEFT_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 5; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.top + i),
						BPoint(r.left + i, r.bottom - i), colors[i]);
				}
			}
			// bottom
			if (invalid.Intersects(fBottomBorder)) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_BOTTOM_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 5; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.bottom - i),
						BPoint(r.right - i, r.bottom - i),
						colors[(4 - i) == 4 ? 5 : (4 - i)]);
				}
			}
			// right
			if (invalid.Intersects(
					fRightBorder.InsetByCopy(0, -fBorderWidth))) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_RIGHT_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 5; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.right - i, r.top + i),
						BPoint(r.right - i, r.bottom - i),
						colors[(4 - i) == 4 ? 5 : (4 - i)]);
				}
			}
			break;
		}

		case B_FLOATING_WINDOW_LOOK:
		case kLeftTitledWindowLook:
		{
			// top
			if (invalid.Intersects(fTopBorder)) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_TOP_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 3; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.top + i),
						BPoint(r.right - i, r.top + i), colors[i * 2]);
				}
				if (fTitleBarRect.IsValid()
					&& fTopTab->look != kLeftTitledWindowLook) {
					// grey along the bottom of the tab
					// (overwrites "white" from frame)
					fDrawingEngine->StrokeLine(
						BPoint(fTitleBarRect.left + 2,
							fTitleBarRect.bottom + 1),
						BPoint(fTitleBarRect.right - 2,
							fTitleBarRect.bottom + 1), colors[2]);
				}
			}
			// left
			if (invalid.Intersects(fLeftBorder.InsetByCopy(0, -fBorderWidth))) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_LEFT_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 3; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.top + i),
						BPoint(r.left + i, r.bottom - i), colors[i * 2]);
				}
				if (fTopTab->look == kLeftTitledWindowLook
					&& fTitleBarRect.IsValid()) {
					// grey along the right side of the tab
					// (overwrites "white" from frame)
					fDrawingEngine->StrokeLine(
						BPoint(fTitleBarRect.right + 1,
							fTitleBarRect.top + 2),
						BPoint(fTitleBarRect.right + 1,
							fTitleBarRect.bottom - 2), colors[2]);
				}
			}
			// bottom
			if (invalid.Intersects(fBottomBorder)) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_BOTTOM_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 3; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.left + i, r.bottom - i),
						BPoint(r.right - i, r.bottom - i),
						colors[(2 - i) == 2 ? 5 : (2 - i) * 2]);
				}
			}
			// right
			if (invalid.Intersects(fRightBorder.InsetByCopy(0, -fBorderWidth))) {
				ComponentColors colors;
				_GetComponentColors(COMPONENT_RIGHT_BORDER, colors, fTopTab);

				for (int8 i = 0; i < 3; i++) {
					fDrawingEngine->StrokeLine(BPoint(r.right - i, r.top + i),
						BPoint(r.right - i, r.bottom - i),
						colors[(2 - i) == 2 ? 5 : (2 - i) * 2]);
				}
			}
			break;
		}

		case B_BORDERED_WINDOW_LOOK:
		{
			// TODO: Draw the borders individually!
			ComponentColors colors;
			_GetComponentColors(COMPONENT_LEFT_BORDER, colors, fTopTab);

			fDrawingEngine->StrokeRect(r, colors[5]);
			break;
		}

		default:
			// don't draw a border frame
			break;
	}

	// Draw the resize knob if we're supposed to
	if (!(fTopTab->flags & B_NOT_RESIZABLE)) {
		r = fResizeRect;

		ComponentColors colors;
		_GetComponentColors(COMPONENT_RESIZE_CORNER, colors, fTopTab);

		switch ((int)fTopTab->look) {
			case B_DOCUMENT_WINDOW_LOOK:
			{
				if (!invalid.Intersects(r))
					break;

				float x = r.right - 3;
				float y = r.bottom - 3;

				BRect bg(x - 13, y - 13, x, y);

				BGradientLinear gradient;
				gradient.SetStart(bg.LeftTop());
				gradient.SetEnd(bg.RightBottom());
				gradient.AddColor(colors[1], 0);
				gradient.AddColor(colors[2], 255);

				fDrawingEngine->FillRect(bg, gradient);

				fDrawingEngine->StrokeLine(BPoint(x - 15, y - 15),
					BPoint(x - 15, y - 2), colors[0]);
				fDrawingEngine->StrokeLine(BPoint(x - 14, y - 14),
					BPoint(x - 14, y - 1), colors[1]);
				fDrawingEngine->StrokeLine(BPoint(x - 15, y - 15),
					BPoint(x - 2, y - 15), colors[0]);
				fDrawingEngine->StrokeLine(BPoint(x - 14, y - 14),
					BPoint(x - 1, y - 14), colors[1]);

				if (fTopTab && !IsFocus(fTopTab))
					break;

				static const rgb_color kWhite
					= (rgb_color){ 255, 255, 255, 255 };
				for (int8 i = 1; i <= 4; i++) {
					for (int8 j = 1; j <= i; j++) {
						BPoint pt1(x - (3 * j) + 1, y - (3 * (5 - i)) + 1);
						BPoint pt2(x - (3 * j) + 2, y - (3 * (5 - i)) + 2);
						fDrawingEngine->StrokePoint(pt1, colors[0]);
						fDrawingEngine->StrokePoint(pt2, kWhite);
					}
				}
				break;
			}

			case B_TITLED_WINDOW_LOOK:
			case B_FLOATING_WINDOW_LOOK:
			case B_MODAL_WINDOW_LOOK:
			case kLeftTitledWindowLook:
			{
				if (!invalid.Intersects(BRect(fRightBorder.right
						- kBorderResizeLength,
					fBottomBorder.bottom - kBorderResizeLength,
					fRightBorder.right - 1, fBottomBorder.bottom - 1))) {
					break;
				}

				fDrawingEngine->StrokeLine(BPoint(fRightBorder.left,
					fBottomBorder.bottom - kBorderResizeLength),
					BPoint(fRightBorder.right - 1,
						fBottomBorder.bottom - kBorderResizeLength),
					colors[0]);
				fDrawingEngine->StrokeLine(
					BPoint(fRightBorder.right - kBorderResizeLength,
						fBottomBorder.top),
					BPoint(fRightBorder.right - kBorderResizeLength,
						fBottomBorder.bottom - 1),
					colors[0]);
				break;
			}

			default:
				// don't draw resize corner
				break;
		}
	}
}


/*!	\brief Actually draws the tab

	This function is called when the tab itself needs drawn. Other items,
	like the window title or buttons, should not be drawn here.

	\param tab The \a tab to update.
	\param invalid The area of the \a tab to update.
*/
void
BeDecorator::_DrawTab(Decorator::Tab* tab, BRect invalid)
{
	STRACE(("_DrawTab(%.1f, %.1f, %.1f, %.1f)\n",
			invalid.left, invalid.top, invalid.right, invalid.bottom));
	const BRect& tabRect = tab->tabRect;
	// If a window has a tab, this will draw it and any buttons which are
	// in it.
	if (!tabRect.IsValid() || !invalid.Intersects(tabRect))
		return;

	ComponentColors colors;
	_GetComponentColors(COMPONENT_TAB, colors, tab);

	// outer frame
	fDrawingEngine->StrokeLine(tabRect.LeftTop(), tabRect.LeftBottom(),
		colors[COLOR_TAB_FRAME_LIGHT]);
	fDrawingEngine->StrokeLine(tabRect.LeftTop(), tabRect.RightTop(),
		colors[COLOR_TAB_FRAME_LIGHT]);
	if (tab->look != kLeftTitledWindowLook) {
		fDrawingEngine->StrokeLine(tabRect.RightTop(), tabRect.RightBottom(),
			colors[COLOR_TAB_FRAME_DARK]);
	} else {
		fDrawingEngine->StrokeLine(tabRect.LeftBottom(),
			tabRect.RightBottom(), colors[COLOR_TAB_FRAME_DARK]);
	}

	float tabBotton = tabRect.bottom;
	if (fTopTab != tab)
		tabBotton -= 1;

	// bevel
	fDrawingEngine->StrokeLine(BPoint(tabRect.left + 1, tabRect.top + 1),
		BPoint(tabRect.left + 1,
			tabBotton - (tab->look == kLeftTitledWindowLook ? 1 : 0)),
		colors[COLOR_TAB_BEVEL]);
	fDrawingEngine->StrokeLine(BPoint(tabRect.left + 1, tabRect.top + 1),
		BPoint(tabRect.right - (tab->look == kLeftTitledWindowLook ? 0 : 1),
			tabRect.top + 1),
		colors[COLOR_TAB_BEVEL]);

	if (tab->look != kLeftTitledWindowLook) {
		fDrawingEngine->StrokeLine(BPoint(tabRect.right - 1, tabRect.top + 2),
			BPoint(tabRect.right - 1, tabBotton),
			colors[COLOR_TAB_SHADOW]);
	} else {
		fDrawingEngine->StrokeLine(
			BPoint(tabRect.left + 2, tabRect.bottom - 1),
			BPoint(tabRect.right, tabRect.bottom - 1),
			colors[COLOR_TAB_SHADOW]);
	}

	// fill
	if (fTopTab->look != kLeftTitledWindowLook) {
		fDrawingEngine->FillRect(BRect(tabRect.left + 2, tabRect.top + 2,
			tabRect.right - 2, tabRect.bottom), colors[COLOR_TAB]);
	} else {
		fDrawingEngine->FillRect(BRect(tabRect.left + 2, tabRect.top + 2,
			tabRect.right, tabRect.bottom - 2), colors[COLOR_TAB]);
	}

	_DrawTitle(tab, tabRect);

	_DrawButtons(tab, invalid);
}


/*!	\brief Actually draws the title

	The main tasks for this function are to ensure that the decorator draws
	the title only in its own area and drawing the title itself.
	Using B_OP_COPY for drawing the title is recommended because of the marked
	performance hit of the other drawing modes, but it is not a requirement.

	\param _tab The \a tab to update.
	\param r area of the title to update.
*/
void
BeDecorator::_DrawTitle(Decorator::Tab* _tab, BRect r)
{
	STRACE(("_DrawTitle(%f, %f, %f, %f)\n", r.left, r.top, r.right, r.bottom));

	Decorator::Tab* tab = static_cast<Decorator::Tab*>(_tab);

	const BRect& tabRect = tab->tabRect;
	const BRect& closeRect = tab->closeRect;
	const BRect& zoomRect = tab->zoomRect;

	ComponentColors colors;
	_GetComponentColors(COMPONENT_TAB, colors, tab);

	fDrawingEngine->SetDrawingMode(B_OP_OVER);
	fDrawingEngine->SetHighColor(colors[COLOR_TAB_TEXT]);
	fDrawingEngine->SetLowColor(colors[COLOR_TAB]);
	fDrawingEngine->SetFont(fDrawState.Font());

	// figure out position of text
	font_height fontHeight;
	fDrawState.Font().GetHeight(fontHeight);

	BPoint titlePos;
	if (fTopTab->look != kLeftTitledWindowLook) {
		titlePos.x = closeRect.IsValid() ? closeRect.right + tab->textOffset
			: tabRect.left + tab->textOffset;
		titlePos.y = floorf(((tabRect.top + 2.0) + tabRect.bottom
			+ fontHeight.ascent + fontHeight.descent) / 2.0
			- fontHeight.descent + 0.5);
	} else {
		titlePos.x = floorf(((tabRect.left + 2.0) + tabRect.right
			+ fontHeight.ascent + fontHeight.descent) / 2.0
			- fontHeight.descent + 0.5);
		titlePos.y = zoomRect.IsValid() ? zoomRect.top - tab->textOffset
			: tabRect.bottom - tab->textOffset;
	}

	fDrawingEngine->SetFont(fDrawState.Font());

	fDrawingEngine->DrawString(tab->truncatedTitle.String(),
		tab->truncatedTitleLength, titlePos);

	fDrawingEngine->SetDrawingMode(B_OP_COPY);
}


/*!	\brief Actually draws the close button

	Unless a subclass has a particularly large button, it is probably
	unnecessary to check the update rectangle.

	\param _tab The \a tab to update.
	\param direct Draw without double buffering.
	\param rect The area of the button to update.
*/
void
BeDecorator::_DrawClose(Decorator::Tab* _tab, bool direct, BRect rect)
{
	STRACE(("_DrawClose(%f,%f,%f,%f)\n", rect.left, rect.top, rect.right,
		rect.bottom));

	Decorator::Tab* tab = static_cast<Decorator::Tab*>(_tab);

	int32 index = (tab->buttonFocus ? 0 : 1) + (tab->closePressed ? 0 : 2);
	ServerBitmap* bitmap = tab->closeBitmaps[index];
	if (bitmap == NULL) {
		bitmap = _GetBitmapForButton(tab, COMPONENT_CLOSE_BUTTON,
			tab->closePressed, rect.IntegerWidth(), rect.IntegerHeight());
		tab->closeBitmaps[index] = bitmap;
	}

	_DrawButtonBitmap(bitmap, direct, rect);
}


/*!	\brief Actually draws the zoom button

	Unless a subclass has a particularly large button, it is probably
	unnecessary to check the update rectangle.

	\param _tab The \a tab to update.
	\param direct Draw without double buffering.
	\param rect The area of the button to update.
*/
void
BeDecorator::_DrawZoom(Decorator::Tab* _tab, bool direct, BRect rect)
{
	STRACE(("_DrawZoom(%f,%f,%f,%f)\n", rect.left, rect.top, rect.right,
		rect.bottom));

	if (rect.IntegerWidth() < 1)
		return;

	Decorator::Tab* tab = static_cast<Decorator::Tab*>(_tab);
	int32 index = (tab->buttonFocus ? 0 : 1) + (tab->zoomPressed ? 0 : 2);
	ServerBitmap* bitmap = tab->zoomBitmaps[index];
	if (bitmap == NULL) {
		bitmap = _GetBitmapForButton(tab, COMPONENT_ZOOM_BUTTON,
			tab->zoomPressed, rect.IntegerWidth(), rect.IntegerHeight());
		tab->zoomBitmaps[index] = bitmap;
	}

	_DrawButtonBitmap(bitmap, direct, rect);
}


void
BeDecorator::_DrawMinimize(Decorator::Tab* tab, bool direct, BRect rect)
{
	// This decorator doesn't have this button
}


void
BeDecorator::_GetButtonSizeAndOffset(const BRect& tabRect, float* _offset,
	float* _size, float* _inset) const
{
	float tabSize = fTopTab->look == kLeftTitledWindowLook ?
		tabRect.Width() : tabRect.Height();

	*_offset = 5.0f;
	*_inset = 0.0f;

	*_size = std::max(0.0f, tabSize - 7.0f);
}


// #pragma mark - Private methods


/*!
	\brief Draws a bevel around a rectangle.
	\param rect The rectangular area to draw in.
	\param down Whether or not the button is pressed down.
	\param light The light color to use.
	\param shadow The shadow color to use.
*/
void
BeDecorator::_DrawBevelRect(DrawingEngine* engine, const BRect rect, bool down,
	rgb_color light, rgb_color shadow)
{
	if (down) {
		BRect inner(rect.InsetByCopy(1.0f, 1.0f));

		engine->StrokeLine(rect.LeftBottom(), rect.LeftTop(), shadow);
		engine->StrokeLine(rect.LeftTop(), rect.RightTop(), shadow);
		engine->StrokeLine(inner.LeftBottom(), inner.LeftTop(), shadow);
		engine->StrokeLine(inner.LeftTop(), inner.RightTop(), shadow);

		engine->StrokeLine(rect.RightTop(), rect.RightBottom(), light);
		engine->StrokeLine(rect.RightBottom(), rect.LeftBottom(), light);
		engine->StrokeLine(inner.RightTop(), inner.RightBottom(), light);
		engine->StrokeLine(inner.RightBottom(), inner.LeftBottom(), light);
	} else {
		BRect r1(rect);
		r1.left += 1.0f;
		r1.top  += 1.0f;

		BRect r2(rect);
		r2.bottom -= 1.0f;
		r2.right  -= 1.0f;

		engine->StrokeRect(r2, shadow);
			// inner dark box
		engine->StrokeRect(rect, shadow);
			// outer dark box
		engine->StrokeRect(r1, light);
			// light box
	}
}


/*!
	\brief Draws a framed rectangle with a gradient.
	\param rect The rectangular area to draw in.
	\param startColor The start color of the gradient.
	\param endColor The end color of the gradient.
*/
void
BeDecorator::_DrawBlendedRect(DrawingEngine* engine, const BRect rect,
	bool down, rgb_color colorA, rgb_color colorB, rgb_color colorC,
	rgb_color colorD)
{
	BRect fillRect(rect.InsetByCopy(1.0f, 1.0f));

	BGradientLinear gradient;
	if (down) {
		gradient.SetStart(fillRect.RightBottom());
		gradient.SetEnd(fillRect.LeftTop());
	} else {
		gradient.SetStart(fillRect.LeftTop());
		gradient.SetEnd(fillRect.RightBottom());
	}

	gradient.AddColor(colorA, 0);
	gradient.AddColor(colorB, 95);
	gradient.AddColor(colorC, 159);
	gradient.AddColor(colorD, 255);

	engine->FillRect(fillRect, gradient);
}


void
BeDecorator::_DrawButtonBitmap(ServerBitmap* bitmap, bool direct, BRect rect)
{
	if (bitmap == NULL)
		return;

	bool copyToFrontEnabled = fDrawingEngine->CopyToFrontEnabled();
	fDrawingEngine->SetCopyToFrontEnabled(direct);
	drawing_mode oldMode;
	fDrawingEngine->SetDrawingMode(B_OP_OVER, oldMode);
	fDrawingEngine->DrawBitmap(bitmap, rect.OffsetToCopy(0, 0), rect);
	fDrawingEngine->SetDrawingMode(oldMode);
	fDrawingEngine->SetCopyToFrontEnabled(copyToFrontEnabled);
}


ServerBitmap*
BeDecorator::_GetBitmapForButton(Decorator::Tab* tab, Component item,
	bool down, int32 width, int32 height)
{
	uint8* data;
	size_t size;
	size_t offset;

	// TODO: the list of shared bitmaps is never freed
	struct decorator_bitmap {
		Component			item;
		bool				down;
		int32				width;
		int32				height;
		rgb_color			baseColor;
		rgb_color			lightColor;
		UtilityBitmap*		bitmap;
		decorator_bitmap*	next;
	};

	static BLocker sBitmapListLock("decorator lock", true);
	static decorator_bitmap* sBitmapList = NULL;

	// BeOS R5 colors
	// button:  active: 255, 203, 0  inactive: 232, 232, 232
	// light1:  active: 255, 238, 0  inactive: 255, 255, 255
	// light2:  active: 255, 255, 26 inactive: 255, 255, 255
	// shadow1: active: 235, 183, 0  inactive: 211, 211, 211
	// shadow2 is a bit lighter on zoom than on close button

	ComponentColors colors;
	_GetComponentColors(item, colors, tab);

	const rgb_color buttonColor(colors[COLOR_BUTTON]);

	bool isGrayscale = buttonColor.red == buttonColor.green
		&& buttonColor.green == buttonColor.blue;

	rgb_color buttonColorLight1(buttonColor);
	buttonColorLight1.red = std::min(255, buttonColor.red + 35),
	buttonColorLight1.green = std::min(255, buttonColor.green + 35),
	buttonColorLight1.blue = std::min(255, buttonColor.blue
		+ (isGrayscale ? 35 : 0));
		// greyscale color stays grayscale

	rgb_color buttonColorLight2(buttonColor);
	buttonColorLight2.red = std::min(255, buttonColor.red + 52),
	buttonColorLight2.green = std::min(255, buttonColor.green + 52),
	buttonColorLight2.blue = std::min(255, buttonColor.blue + 26);

	rgb_color buttonColorShadow1(buttonColor);
	buttonColorShadow1.red = std::max(0, buttonColor.red - 21),
	buttonColorShadow1.green = std::max(0, buttonColor.green - 21),
	buttonColorShadow1.blue = std::max(0, buttonColor.blue - 21);

	BAutolock locker(sBitmapListLock);

	// search our list for a matching bitmap
	// TODO: use a hash map instead?
	decorator_bitmap* current = sBitmapList;
	while (current) {
		if (current->item == item && current->down == down
			&& current->width == width && current->height == height
			&& current->baseColor == colors[COLOR_BUTTON]
			&& current->lightColor == colors[COLOR_BUTTON_LIGHT]) {
			return current->bitmap;
		}

		current = current->next;
	}

	static BitmapDrawingEngine* sBitmapDrawingEngine = NULL;

	// didn't find any bitmap, create a new one
	if (sBitmapDrawingEngine == NULL)
		sBitmapDrawingEngine = new(std::nothrow) BitmapDrawingEngine();
	if (sBitmapDrawingEngine == NULL
		|| sBitmapDrawingEngine->SetSize(width, height) != B_OK) {
		return NULL;
	}

	BRect rect(0, 0, width - 1, height - 1);

	STRACE(("BeDecorator creating bitmap for %s %s at size %ldx%ld\n",
		item == COMPONENT_CLOSE_BUTTON ? "close" : "zoom",
		down ? "down" : "up", width, height));
	switch (item) {
		case COMPONENT_CLOSE_BUTTON:
		{
			// BeOS R5 shadow2: active: 183, 131, 0 inactive: 160, 160, 160
			rgb_color buttonColorShadow2(buttonColor);
			buttonColorShadow2.red = std::max(0, buttonColor.red - 72),
			buttonColorShadow2.green = std::max(0, buttonColor.green - 72),
			buttonColorShadow2.blue = std::max(0, buttonColor.blue - 72);

			// fill the background
			sBitmapDrawingEngine->FillRect(rect, buttonColor);

			// draw outer bevel
			_DrawBevelRect(sBitmapDrawingEngine, rect, tab->closePressed,
				buttonColorLight2, buttonColorShadow2);

			if (fCStatus != B_OK) {
				// If we ran out of memory while initializing bitmaps
				// fall back to a linear gradient.
				rect.InsetBy(1, 1);
				_DrawBlendedRect(sBitmapDrawingEngine, rect, tab->closePressed,
					buttonColorLight2, buttonColorLight1, buttonColor,
					buttonColorShadow1);

				break;
			}

			// inset by bevel
			rect.InsetBy(2, 2);

			// fill bg
			sBitmapDrawingEngine->FillRect(rect, buttonColorLight1);

			// treat background color as transparent
			sBitmapDrawingEngine->SetDrawingMode(B_OP_OVER);
			sBitmapDrawingEngine->SetLowColor(buttonColorLight1);

			if (tab->closePressed) {
				// Draw glint in bottom right, then combined inner and outer
				// shadow in top left.
				// Read the source bitmap in forward while writing the
				// destination in reverse to rotate the bitmap by 180°.

				data = fGlintBitmap->Bits();
				size = sizeof(kGlintBits);
				for (size_t i = 0; i < size; i++) {
					offset = (size - 1 - i) * 4;
					if (kGlintBits[i] == 0) {
						// draw glint color
						data[offset + 0] = buttonColorLight2.blue;
						data[offset + 1] = buttonColorLight2.green;
						data[offset + 2] = buttonColorLight2.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// glint is 3x3
				const BRect rightBottom(BRect(rect.right - 2, rect.bottom - 2,
					rect.right, rect.bottom));
				sBitmapDrawingEngine->DrawBitmap(fGlintBitmap,
					fGlintBitmap->Bounds(), rightBottom);

				data = fCloseBitmap->Bits();
				size = sizeof(kOuterShadowBits);
				for (size_t i = 0; i < size; i++) {
					offset = (size - 1 - i) * 4;
					if (kOuterShadowBits[i] == 0) {
						// draw outer shadow
						data[offset + 0] = buttonColorShadow1.blue;
						data[offset + 1] = buttonColorShadow1.green;
						data[offset + 2] = buttonColorShadow1.red;
					} else if (kInnerShadowBits[i] == 0) {
						// draw inner shadow
						data[offset + 0] = buttonColor.blue;
						data[offset + 1] = buttonColor.green;
						data[offset + 2] = buttonColor.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// shadow is 10x10
				const BRect leftTop(rect.left, rect.top,
					rect.left + 9, rect.top + 9);
				sBitmapDrawingEngine->DrawBitmap(fCloseBitmap,
					fCloseBitmap->Bounds(), leftTop);
			} else {
				// draw glint, then draw combined outer and inner shadows

				data = fGlintBitmap->Bits();
				size = sizeof(kGlintBits);
				for (size_t i = 0; i < size; i++) {
					offset = i * 4 + 0;
					if (kGlintBits[i] == 0) {
						// draw glint color
						data[offset + 0] = buttonColorLight2.blue;
						data[offset + 1] = buttonColorLight2.green;
						data[offset + 2] = buttonColorLight2.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// glint is 3x3
				const BRect leftTop(rect.left, rect.top,
					rect.left + 2, rect.top + 2);
				sBitmapDrawingEngine->DrawBitmap(fGlintBitmap,
					fGlintBitmap->Bounds(), leftTop);

				data = fCloseBitmap->Bits();
				size = sizeof(kOuterShadowBits);
				for (size_t i = 0; i < size; i++) {
					offset = i * 4 + 0;
					if (kOuterShadowBits[i] == 0) {
						// draw outer shadow
						data[offset + 0] = buttonColorShadow1.blue;
						data[offset + 1] = buttonColorShadow1.green;
						data[offset + 2] = buttonColorShadow1.red;
					} else if (kInnerShadowBits[i] == 0) {
						// draw inner shadow
						data[offset + 0] = buttonColor.blue;
						data[offset + 1] = buttonColor.green;
						data[offset + 2] = buttonColor.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// shadow is 10x10
				const BRect rightBottom(BRect(rect.right - 9, rect.bottom - 9,
					rect.right, rect.bottom));
				sBitmapDrawingEngine->DrawBitmap(fCloseBitmap,
					fCloseBitmap->Bounds(), rightBottom);
			}

			// restore drawing mode
			sBitmapDrawingEngine->SetDrawingMode(B_OP_COPY);

			break;
		}

		case COMPONENT_ZOOM_BUTTON:
		{
			// BeOS R5 shadow2: active: 210, 158, 0 inactive: 187, 187, 187
			rgb_color buttonColorShadow2(buttonColor);
			buttonColorShadow2.red = std::max(0, buttonColor.red - 45),
			buttonColorShadow2.green = std::max(0, buttonColor.green - 45),
			buttonColorShadow2.blue = std::max(0, buttonColor.blue - 45);

			// fill the background
			sBitmapDrawingEngine->FillRect(rect, buttonColor);

			// big rect
			BRect bigRect(rect);
			bigRect.left += floorf(width * 3.0f / 14.0f);
			bigRect.top += floorf(height * 3.0f / 14.0f);

			// small rect
			BRect smallRect(rect);
			smallRect.right -= floorf(width * 5.0f / 14.0f);
			smallRect.bottom -= floorf(height * 5.0f / 14.0f);

			// draw big rect bevel
			_DrawBevelRect(sBitmapDrawingEngine, bigRect, tab->zoomPressed,
				buttonColorLight2, buttonColorShadow2);

			if (fCStatus != B_OK) {
				// If we ran out of memory while initializing bitmaps
				// fall back to a linear gradient.

				// already drew bigRect bevel, fill with linear gradient
				bigRect.InsetBy(1, 1);
				_DrawBlendedRect(sBitmapDrawingEngine, bigRect,
					tab->zoomPressed, buttonColorLight2, buttonColorLight1,
					buttonColor, buttonColorShadow1);

				// draw small rect bevel then fill with linear gradient
				_DrawBevelRect(sBitmapDrawingEngine, smallRect,
					tab->zoomPressed, buttonColorLight2, buttonColorShadow2);
				if (!tab->zoomPressed) {
					// undraw bottom left and top right corners
					sBitmapDrawingEngine->StrokePoint(smallRect.LeftBottom(),
						buttonColor);
					sBitmapDrawingEngine->StrokePoint(smallRect.RightTop(),
						buttonColor);
				}
				smallRect.InsetBy(1, 1);
				_DrawBlendedRect(sBitmapDrawingEngine, smallRect,
					tab->zoomPressed, buttonColorLight2, buttonColorLight1,
					buttonColor, buttonColorShadow1);

				break;
			}

			// inset past bevel
			bigRect.InsetBy(2, 2);

			// fill big rect bg
			sBitmapDrawingEngine->FillRect(bigRect, buttonColorLight1);

			// some elements are covered by the small rect
			// so only draw the parts that get shown
			if (tab->zoomPressed) {
				// draw glint
				// Read the source bitmap in forward while writing the
				// destination in reverse to rotate the bitmap by 180°.
				data = fGlintBitmap->Bits();
				size = sizeof(kGlintBits);
				for (size_t i = 0; i < sizeof(kGlintBits); i++) {
					offset = (size - 1 - i) * 4;
					if (kGlintBits[i] == 0) {
						// draw glint
						data[offset + 0] = buttonColorLight2.blue;
						data[offset + 1] = buttonColorLight2.green;
						data[offset + 2] = buttonColorLight2.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// glint is 3x3
				const BRect rightBottom(BRect(bigRect.right - 2,
					bigRect.bottom - 2, bigRect.right, bigRect.bottom));
				sBitmapDrawingEngine->DrawBitmap(fGlintBitmap,
					fGlintBitmap->Bounds(), rightBottom);
			} else {
				// draw combined inner and outer shadow
				data = fBigZoomBitmap->Bits();
				for (size_t i = 0; i < sizeof(kBigOuterShadowBits); i++) {
					offset = i * 4;
					if (kBigOuterShadowBits[i] == 0) {
						// draw outer shadow
						data[offset + 0] = buttonColorShadow1.blue;
						data[offset + 1] = buttonColorShadow1.green;
						data[offset + 2] = buttonColorShadow1.red;
					} else if (kBigInnerShadowBits[i] == 0) {
						// draw inner shadow
						data[offset + 0] = buttonColor.blue;
						data[offset + 1] = buttonColor.green;
						data[offset + 2] = buttonColor.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// shadow is 7x7
				const BRect rightBottom(BRect(bigRect.right - 6,
					bigRect.bottom - 6, bigRect.right, bigRect.bottom));
				sBitmapDrawingEngine->DrawBitmap(fBigZoomBitmap,
					fBigZoomBitmap->Bounds(), rightBottom);
			}

			sBitmapDrawingEngine->SetDrawingMode(B_OP_COPY);

			// draw small rect bevel
			_DrawBevelRect(sBitmapDrawingEngine, smallRect, tab->zoomPressed,
				buttonColorLight2, buttonColorShadow2);

			if (!tab->zoomPressed) {
				// undraw bottom left and top right corners
				sBitmapDrawingEngine->StrokePoint(smallRect.LeftBottom(),
					buttonColor);
				sBitmapDrawingEngine->StrokePoint(smallRect.RightTop(),
					buttonColor);
			}

			// inset past bevel
			smallRect.InsetBy(2, 2);

			// fill small rect bg
			sBitmapDrawingEngine->FillRect(smallRect, buttonColorLight1);

			// treat background color as transparent
			sBitmapDrawingEngine->SetDrawingMode(B_OP_OVER);
			sBitmapDrawingEngine->SetLowColor(buttonColorLight1);

			// draw small bitmap
			data = fSmallZoomBitmap->Bits();
			size = sizeof(kSmallOuterShadowBits);
			if (tab->zoomPressed) {
				// draw combined inner and outer shadow
				// Read the source bitmap in forward while writing the
				// destination in reverse to rotate the bitmap by 180°.
				for (size_t i = 0; i < size; i++) {
					offset = (size - 1 - i) * 4;
					if (kSmallOuterShadowBits[i] == 0) {
						// draw outer shadow
						data[offset + 0] = buttonColorShadow1.blue;
						data[offset + 1] = buttonColorShadow1.green;
						data[offset + 2] = buttonColorShadow1.red;
					} else if (kSmallInnerShadowBits[i] == 0) {
						// draw inner shadow
						data[offset + 0] = buttonColor.blue;
						data[offset + 1] = buttonColor.green;
						data[offset + 2] = buttonColor.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// shadow is 5x5
				const BRect smallLeftTop(BRect(smallRect.left,
					smallRect.top, smallRect.left + 4, smallRect.top + 4));
				sBitmapDrawingEngine->DrawBitmap(fSmallZoomBitmap,
					fSmallZoomBitmap->Bounds(), smallLeftTop);
			} else {
				// draw combined inner and outer shadow
				for (size_t i = 0; i < size; i++) {
					offset = i * 4;
					if (kSmallOuterShadowBits[i] == 0) {
						// draw outer shadow
						data[offset + 0] = buttonColorShadow1.blue;
						data[offset + 1] = buttonColorShadow1.green;
						data[offset + 2] = buttonColorShadow1.red;
					} else if (kSmallInnerShadowBits[i] == 0) {
						// draw inner shadow
						data[offset + 0] = buttonColor.blue;
						data[offset + 1] = buttonColor.green;
						data[offset + 2] = buttonColor.red;
					} else {
						// draw background color
						data[offset + 0] = buttonColorLight1.blue;
						data[offset + 1] = buttonColorLight1.green;
						data[offset + 2] = buttonColorLight1.red;
					}
				}
				// shadow is 5x5
				const BRect smallRightBottom(BRect(smallRect.right - 4,
					smallRect.bottom - 4, smallRect.right, smallRect.bottom));
				sBitmapDrawingEngine->DrawBitmap(fSmallZoomBitmap,
					fSmallZoomBitmap->Bounds(), smallRightBottom);
			}

			// draw glint last (single pixel)
			sBitmapDrawingEngine->StrokePoint(tab->zoomPressed
					? smallRect.RightBottom() : smallRect.LeftTop(),
				buttonColorLight2);

			// restore drawing mode
			sBitmapDrawingEngine->SetDrawingMode(B_OP_COPY);

			break;
		}

		default:
			break;
	}

	UtilityBitmap* bitmap = sBitmapDrawingEngine->ExportToBitmap(width, height,
		B_RGB32);
	if (bitmap == NULL)
		return NULL;

	// bitmap ready, put it into the list
	decorator_bitmap* entry = new(std::nothrow) decorator_bitmap;
	if (entry == NULL) {
		delete bitmap;
		return NULL;
	}

	entry->item = item;
	entry->down = down;
	entry->width = width;
	entry->height = height;
	entry->bitmap = bitmap;
	entry->baseColor = colors[COLOR_BUTTON];
	entry->lightColor = colors[COLOR_BUTTON_LIGHT];
	entry->next = sBitmapList;
	sBitmapList = entry;
	return bitmap;
}


ServerBitmap*
BeDecorator::_CreateTemporaryBitmap(BRect bounds) const
{
	UtilityBitmap* bitmap = new(std::nothrow) UtilityBitmap(bounds,
		B_RGB32, 0);
	if (bitmap == NULL)
		return NULL;

	if (!bitmap->IsValid()) {
		delete bitmap;
		return NULL;
	}

	memset(bitmap->Bits(), 0, bitmap->BitsLength());
		// background opacity is 0

	return bitmap;
}


void
BeDecorator::_GetComponentColors(Component component,
	ComponentColors _colors, Decorator::Tab* tab)
{
	// get the highlight for our component
	Region region = REGION_NONE;
	switch (component) {
		case COMPONENT_TAB:
			region = REGION_TAB;
			break;
		case COMPONENT_CLOSE_BUTTON:
			region = REGION_CLOSE_BUTTON;
			break;
		case COMPONENT_ZOOM_BUTTON:
			region = REGION_ZOOM_BUTTON;
			break;
		case COMPONENT_LEFT_BORDER:
			region = REGION_LEFT_BORDER;
			break;
		case COMPONENT_RIGHT_BORDER:
			region = REGION_RIGHT_BORDER;
			break;
		case COMPONENT_TOP_BORDER:
			region = REGION_TOP_BORDER;
			break;
		case COMPONENT_BOTTOM_BORDER:
			region = REGION_BOTTOM_BORDER;
			break;
		case COMPONENT_RESIZE_CORNER:
			region = REGION_RIGHT_BOTTOM_CORNER;
			break;
	}

	return GetComponentColors(component, RegionHighlight(region), _colors, tab);
}


extern "C" DecorAddOn* (instantiate_decor_addon)(image_id id, const char* name)
{
	return new (std::nothrow)BeDecorAddOn(id, name);
}