/*
 * Copyright 2009-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		DarkWyrm, bpmagic@columbus.rr.com
 *		Adrien Destugues, pulkomandy@gmail.com
 *		John Scipione, jscipione@gmail.com
 */


/*! Decorator resembling Mac OS 8 and 9 */


#include "MacDecorator.h"

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

#include <GradientLinear.h>
#include <Point.h>
#include <View.h>

#include "DesktopSettings.h"
#include "DrawingEngine.h"
#include "PatternHandler.h"
#include "RGBColor.h"


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


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


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


MacDecorator::MacDecorator(DesktopSettings& settings, BRect frame,
	Desktop* desktop)
	:
	SATDecorator(settings, frame, desktop),
	fButtonHighColor((rgb_color) { 232, 232, 232, 255 }),
	fButtonLowColor((rgb_color) { 128, 128, 128, 255 }),
	fFrameHighColor((rgb_color) { 255, 255, 255, 255 }),
	fFrameMidColor((rgb_color) { 216, 216, 216, 255 }),
	fFrameLowColor((rgb_color) { 156, 156, 156, 255 }),
	fFrameLowerColor((rgb_color) { 0, 0, 0, 255 }),
	fFocusTextColor(settings.UIColor(B_WINDOW_TEXT_COLOR)),
	fNonFocusTextColor(settings.UIColor(B_WINDOW_INACTIVE_TEXT_COLOR))
{
	STRACE(("MacDecorator()\n"));
	STRACE(("\tFrame (%.1f,%.1f,%.1f,%.1f)\n",
		frame.left, frame.top, frame.right, frame.bottom));
}


MacDecorator::~MacDecorator()
{
	STRACE(("~MacDecorator()\n"));
}


// TODO : Add GetSettings


void
MacDecorator::Draw(BRect updateRect)
{
	STRACE(("MacDecorator: Draw(BRect updateRect): "));
	updateRect.PrintToStream();

	// We need to draw a few things: the tab, the borders,
	// and the buttons
	fDrawingEngine->SetDrawState(&fDrawState);

	_DrawFrame(updateRect & fBorderRect);
	_DrawTabs(updateRect & fTitleBarRect);
}


void
MacDecorator::Draw()
{
	STRACE("MacDecorator::Draw()\n");
	fDrawingEngine->SetDrawState(&fDrawState);

	_DrawFrame(fBorderRect);
	_DrawTabs(fTitleBarRect);
}


// TODO : add GetSizeLimits


Decorator::Region
MacDecorator::RegionAt(BPoint where, int32& tab) const
{
	// Let the base class version identify hits of the buttons and the tab.
	Region region = Decorator::RegionAt(where, tab);
	if (region != REGION_NONE)
		return region;

	// check the resize corner
	if (fTopTab->look == B_DOCUMENT_WINDOW_LOOK && fResizeRect.Contains(where))
		return REGION_RIGHT_BOTTOM_CORNER;

	// hit-test the borders
	if (!(fTopTab->flags & B_NOT_RESIZABLE)
		&& (fTopTab->look == B_TITLED_WINDOW_LOOK
			|| fTopTab->look == B_FLOATING_WINDOW_LOOK
			|| fTopTab->look == B_MODAL_WINDOW_LOOK)
		&& fBorderRect.Contains(where) && !fFrame.Contains(where)) {
		return REGION_BOTTOM_BORDER;
			// TODO: Determine the actual border!
	}

	return REGION_NONE;
}


bool
MacDecorator::SetRegionHighlight(Region region, uint8 highlight,
	BRegion* dirty, int32 tabIndex)
{
	Decorator::Tab* tab
		= static_cast<Decorator::Tab*>(_TabAt(tabIndex));
	if (tab != NULL) {
		tab->isHighlighted = highlight != 0;
		// Invalidate the bitmap caches for the close/minimize/zoom button
		// when the highlight changes.
		switch (region) {
			case REGION_CLOSE_BUTTON:
				if (highlight != RegionHighlight(region))
					memset(&tab->closeBitmaps, 0, sizeof(tab->closeBitmaps));
				break;

			case REGION_MINIMIZE_BUTTON:
				if (highlight != RegionHighlight(region)) {
					memset(&tab->minimizeBitmaps, 0,
						sizeof(tab->minimizeBitmaps));
				}
				break;

			case REGION_ZOOM_BUTTON:
				if (highlight != RegionHighlight(region))
					memset(&tab->zoomBitmaps, 0, sizeof(tab->zoomBitmaps));
				break;

			default:
				break;
		}
	}

	return Decorator::SetRegionHighlight(region, highlight, dirty, tabIndex);
}


void
MacDecorator::_DoLayout()
{
	STRACE(("MacDecorator: Do Layout\n"));

	// Here we determine the size of every rectangle that we use
	// internally when we are given the size of the client rectangle.

	const int32 kDefaultBorderWidth = 6;

	bool hasTab = false;

	if (fTopTab) {
		switch (fTopTab->look) {
			case B_MODAL_WINDOW_LOOK:
				fBorderWidth = kDefaultBorderWidth;
				break;

			case B_TITLED_WINDOW_LOOK:
			case B_DOCUMENT_WINDOW_LOOK:
				hasTab = true;
				fBorderWidth = kDefaultBorderWidth;
				break;

			case B_FLOATING_WINDOW_LOOK:
				hasTab = true;
				fBorderWidth = 3;
				break;

			case B_BORDERED_WINDOW_LOOK:
				fBorderWidth = 1;
				break;

			default:
				fBorderWidth = 0;
		}
	} else
		fBorderWidth = 0;

	fBorderRect = fFrame.InsetByCopy(-fBorderWidth, -fBorderWidth);

	// calculate our tab rect
	if (hasTab) {
		fBorderRect.top += 3;

		font_height fontHeight;
		fDrawState.Font().GetHeight(fontHeight);

		// TODO the tab is drawn in a fixed height for now
		fTitleBarRect.Set(fFrame.left - fBorderWidth,
			fFrame.top - 22,
			((fFrame.right - fFrame.left) < 32.0 ?
				fFrame.left + 32.0 : fFrame.right) + fBorderWidth,
			fFrame.top - 3);

		for (int32 i = 0; i < fTabList.CountItems(); i++) {
			Decorator::Tab* tab = fTabList.ItemAt(i);

			tab->tabRect = fTitleBarRect;
				// TODO actually handle multiple tabs

			tab->zoomRect = fTitleBarRect;
			tab->zoomRect.left = tab->zoomRect.right - 12;
			tab->zoomRect.bottom = tab->zoomRect.top + 12;
			tab->zoomRect.OffsetBy(-4, 4);

			tab->closeRect = tab->zoomRect;
			tab->minimizeRect = tab->zoomRect;

			tab->closeRect.OffsetTo(fTitleBarRect.left + 4,
				fTitleBarRect.top + 4);

			tab->zoomRect.OffsetBy(0 - (tab->zoomRect.Width() + 4), 0);
			if (Title(tab) != NULL && fDrawingEngine != NULL) {
				tab->truncatedTitle = Title(tab);
				fDrawingEngine->SetFont(fDrawState.Font());
				tab->truncatedTitleLength
					= (int32)fDrawingEngine->StringWidth(Title(tab),
						strlen(Title(tab)));

				if (tab->truncatedTitleLength < (tab->zoomRect.left
						- tab->closeRect.right - 10)) {
					// start with offset from closerect.right
					tab->textOffset = int(((tab->zoomRect.left - 5)
						- (tab->closeRect.right + 5)) / 2);
					tab->textOffset -= int(tab->truncatedTitleLength / 2);

					// now make it the offset from fTabRect.left
					tab->textOffset += int(tab->closeRect.right + 5
						- fTitleBarRect.left);
				} else
					tab->textOffset = int(tab->closeRect.right) + 5;
			} else
				tab->textOffset = 0;
		}
	} else {
		for (int32 i = 0; i < fTabList.CountItems(); i++) {
			Decorator::Tab* tab = fTabList.ItemAt(i);

			tab->tabRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->closeRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->zoomRect.Set(0.0, 0.0, -1.0, -1.0);
			tab->minimizeRect.Set(0.0, 0.0, -1.0, -1.0);
		}
	}
}


void
MacDecorator::_DrawFrame(BRect invalid)
{
	if (fTopTab->look == B_NO_BORDER_WINDOW_LOOK)
		return;

	if (fBorderWidth <= 0)
		return;

	BRect r = fBorderRect;
	switch (fTopTab->look) {
		case B_TITLED_WINDOW_LOOK:
		case B_DOCUMENT_WINDOW_LOOK:
		case B_MODAL_WINDOW_LOOK:
		{
			if (IsFocus(fTopTab)) {
				BPoint offset = r.LeftTop();
				BPoint pt2 = r.LeftBottom();

				// Draw the left side of the frame
				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
				offset.x++;
				pt2.x++;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameHighColor);
				offset.x++;
				pt2.x++;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x++;
				pt2.x++;
				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x++;
				pt2.x++;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowColor);
				offset.x++;
				offset.y += 2;
				BPoint topleftpt = offset;
				pt2.x++;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);

				offset = r.RightTop();
				pt2 = r.RightBottom();

				// Draw the right side of the frame
				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
				offset.x--;
				pt2.x--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowColor);
				offset.x--;
				pt2.x--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x--;
				pt2.x--;
				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x--;
				pt2.x--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameHighColor);
				offset.x--;
				offset.y += 2;
				BPoint toprightpt = offset;
				pt2.x--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);

				// Draw the top side of the frame that is not in the tab
				if (fTopTab->look == B_MODAL_WINDOW_LOOK) {
					offset = r.LeftTop();
					pt2 = r.RightTop();

					fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
					offset.x++;
					offset.y++;
					pt2.x--;
					pt2.y++;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameHighColor);
					offset.x++;
					offset.y++;
					pt2.x--;
					pt2.y++;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
					offset.x++;
					offset.y++;
					pt2.x--;
					pt2.y++;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
					offset.x++;
					offset.y++;
					pt2.x--;
					pt2.y++;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameLowColor);
					offset.x++;
					offset.y++;
					pt2.x--;
					pt2.y++;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
				} else {
					// Some odd stuff here where the title bar is melded into the
					// window border so that the sides are drawn into the title
					// so we draw this bottom up 
					offset = topleftpt;
					pt2 = toprightpt;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
					offset.y--;
					offset.x++;
					pt2.y--;

					fDrawingEngine->StrokeLine(offset, pt2, fFrameLowColor);
				}

				// Draw the bottom side of the frame
				offset = r.LeftBottom();
				pt2 = r.RightBottom();

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
				offset.x++;
				offset.y--;
				pt2.x--;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowColor);
				offset.x++;
				offset.y--;
				pt2.x--;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x++;
				offset.y--;
				pt2.x--;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameMidColor);
				offset.x++;
				offset.y--;
				pt2.x--;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameHighColor);
				offset.x += 2;
				offset.y--;
				pt2.x--;
				pt2.y--;

				fDrawingEngine->StrokeLine(offset, pt2, fFrameLowerColor);
				offset.y--;
				pt2.x--;
				pt2.y--;
			} else {
				r.top -= 3;
				RGBColor inactive(82, 82, 82);

				fDrawingEngine->StrokeLine(r.LeftTop(), r.LeftBottom(),
					inactive);
				fDrawingEngine->StrokeLine(r.RightTop(), r.RightBottom(),
					inactive);
				fDrawingEngine->StrokeLine(r.LeftBottom(), r.RightBottom(),
					inactive);

				for (int i = 0; i < 4; i++) {
					r.InsetBy(1, 1);
					fDrawingEngine->StrokeLine(r.LeftTop(), r.LeftBottom(),
						fFrameMidColor);
					fDrawingEngine->StrokeLine(r.RightTop(), r.RightBottom(),
						fFrameMidColor);
					fDrawingEngine->StrokeLine(r.LeftBottom(), r.RightBottom(),
						fFrameMidColor);
					fDrawingEngine->StrokeLine(r.LeftTop(), r.RightTop(),
						fFrameMidColor);
				}

				r.InsetBy(1, 1);
				fDrawingEngine->StrokeLine(r.LeftTop(), r.LeftBottom(),
					inactive);
				fDrawingEngine->StrokeLine(r.RightTop(), r.RightBottom(),
					inactive);
				fDrawingEngine->StrokeLine(r.LeftBottom(), r.RightBottom(),
					inactive);
				fDrawingEngine->StrokeLine(r.LeftTop(), r.RightTop(),
					inactive);
			}
			break;
		}
		case B_BORDERED_WINDOW_LOOK:
			fDrawingEngine->StrokeRect(r, fFrameMidColor);
			break;

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


void
MacDecorator::_DrawTab(Decorator::Tab* tab, BRect invalid)
{
	// If a window has a tab, this will draw it and any buttons which are
	// in it.
	if (!tab->tabRect.IsValid() || !invalid.Intersects(tab->tabRect))
		return;

	BRect rect(tab->tabRect);
	fDrawingEngine->SetHighColor(RGBColor(fFrameMidColor));
	fDrawingEngine->FillRect(rect, fFrameMidColor);

	if (IsFocus(tab)) {
		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop(),
			fFrameLowerColor);
		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftBottom(),
			fFrameLowerColor);
		fDrawingEngine->StrokeLine(rect.RightBottom(), rect.RightTop(),
			fFrameLowerColor);

		rect.InsetBy(1, 1);
		rect.bottom++;

		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop(),
			fFrameHighColor);
		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftBottom(),
			fFrameHighColor);
		fDrawingEngine->StrokeLine(rect.RightBottom(), rect.RightTop(),
			fFrameLowColor);

		// Draw the neat little lines on either side of the title if there's
		// room
		float left;
		if ((tab->flags & B_NOT_CLOSABLE) == 0)
			left = tab->closeRect.right;
		else
			left = tab->tabRect.left;

		float right;
		if ((tab->flags & B_NOT_ZOOMABLE) == 0)
			right = tab->zoomRect.left;
		else if ((tab->flags & B_NOT_MINIMIZABLE) == 0)
			right = tab->minimizeRect.left;
		else
			right = tab->tabRect.right;

		if (tab->tabRect.left + tab->textOffset > left + 5) {
			RGBColor dark(115, 115, 115);

			// Left side

			BPoint offset(left + 5, tab->closeRect.top);
			BPoint pt2(tab->tabRect.left + tab->textOffset - 5,
				tab->closeRect.top);

			fDrawState.SetHighColor(RGBColor(fFrameHighColor));
			for (int32 i = 0; i < 6; i++) {
				fDrawingEngine->StrokeLine(offset, pt2,
					fDrawState.HighColor());
				offset.y += 2;
				pt2.y += 2;
			}

			offset.Set(left + 6, tab->closeRect.top + 1);
			pt2.Set(tab->tabRect.left + tab->textOffset - 4,
				tab->closeRect.top + 1);

			fDrawState.SetHighColor(dark);
			for (int32 i = 0; i < 6; i++) {
				fDrawingEngine->StrokeLine(offset, pt2,
					fDrawState.HighColor());
				offset.y += 2;
				pt2.y += 2;
			}

			// Right side

			offset.Set(tab->tabRect.left + tab->textOffset
				+ tab->truncatedTitleLength + 3, tab->zoomRect.top);
			pt2.Set(right - 8, tab->zoomRect.top);

			if (offset.x < pt2.x) {
				fDrawState.SetHighColor(RGBColor(fFrameHighColor));
				for (int32 i = 0; i < 6; i++) {
					fDrawingEngine->StrokeLine(offset, pt2,
						fDrawState.HighColor());
					offset.y += 2;
					pt2.y += 2;
				}

				offset.Set(tab->tabRect.left + tab->textOffset
					+ tab->truncatedTitleLength + 4, tab->zoomRect.top + 1);
				pt2.Set(right - 7, tab->zoomRect.top + 1);

				fDrawState.SetHighColor(dark);
				for(int32 i = 0; i < 6; i++) {
					fDrawingEngine->StrokeLine(offset, pt2,
						fDrawState.HighColor());
					offset.y += 2;
					pt2.y += 2;
				}
			}
		}

		_DrawButtons(tab, rect);
	} else {
		RGBColor inactive(82, 82, 82);
		// Not focused - Just draw a plain light grey area with the title
		// in the middle
		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop(),
			inactive);
		fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftBottom(),
			inactive);
		fDrawingEngine->StrokeLine(rect.RightBottom(), rect.RightTop(),
			inactive);
	}

	_DrawTitle(tab, tab->tabRect);
}


void
MacDecorator::_DrawButtons(Decorator::Tab* tab, const BRect& invalid)
{
	if ((tab->flags & B_NOT_CLOSABLE) == 0
		&& invalid.Intersects(tab->closeRect)) {
		_DrawClose(tab, false, tab->closeRect);
	}
	if ((tab->flags & B_NOT_MINIMIZABLE) == 0
		&& invalid.Intersects(tab->minimizeRect)) {
		_DrawMinimize(tab, false, tab->minimizeRect);
	}
	if ((tab->flags & B_NOT_ZOOMABLE) == 0
		&& invalid.Intersects(tab->zoomRect)) {
		_DrawZoom(tab, false, tab->zoomRect);
	}
}


void
MacDecorator::_DrawTitle(Decorator::Tab* tab, BRect rect)
{
	fDrawingEngine->SetHighColor(IsFocus(tab)
		? fFocusTextColor : fNonFocusTextColor);

	fDrawingEngine->SetLowColor(fFrameMidColor);

	tab->truncatedTitle = Title(tab);
	fDrawState.Font().TruncateString(&tab->truncatedTitle, B_TRUNCATE_END,
		(tab->zoomRect.left - 5) - (tab->closeRect.right + 5));
	fDrawingEngine->SetFont(fDrawState.Font());

	fDrawingEngine->DrawString(tab->truncatedTitle, tab->truncatedTitle.Length(),
		BPoint(fTitleBarRect.left + tab->textOffset,
			tab->closeRect.bottom - 1));
}


void
MacDecorator::_DrawClose(Decorator::Tab* tab, bool direct, BRect r)
{
	_DrawButton(tab, direct, r, tab->closePressed);
}


void
MacDecorator::_DrawZoom(Decorator::Tab* tab, bool direct, BRect rect)
{
	_DrawButton(tab, direct, rect, tab->zoomPressed);

	rect.top++;
	rect.left++;
	rect.bottom = rect.top + 6;
	rect.right = rect.left + 6;

	fDrawState.SetHighColor(RGBColor(33, 33, 33));
	fDrawingEngine->StrokeRect(rect, fDrawState.HighColor());
}


void
MacDecorator::_DrawMinimize(Decorator::Tab* tab, bool direct, BRect rect)
{
	_DrawButton(tab, direct, rect, tab->minimizePressed);

	rect.InsetBy(1, 5);

	fDrawState.SetHighColor(RGBColor(33, 33, 33));
	fDrawingEngine->StrokeRect(rect, fDrawState.HighColor());
}


void
MacDecorator::_SetTitle(Tab* tab, const char* string, BRegion* updateRegion)
{
	// TODO: we could be much smarter about the update region
	// TODO may this change the other tabs too ? (to make space for a longer
	// title ?)

	BRect rect = TabRect(tab);

	_DoLayout();

	if (updateRegion == NULL)
		return;

	rect = rect | TabRect(tab);

	rect.bottom++;
		// the border will look differently when the title is adjacent

	updateRegion->Include(rect);
}


// TODO : _SetFocus


void
MacDecorator::_MoveBy(BPoint offset)
{
	// Move all internal rectangles the appropriate amount
	for (int32 i = 0; i < fTabList.CountItems(); i++) {
		Decorator::Tab* tab = fTabList.ItemAt(i);
		tab->zoomRect.OffsetBy(offset);
		tab->minimizeRect.OffsetBy(offset);
		tab->closeRect.OffsetBy(offset);
		tab->tabRect.OffsetBy(offset);
	}

	fFrame.OffsetBy(offset);
	fTitleBarRect.OffsetBy(offset);
	fResizeRect.OffsetBy(offset);
	fBorderRect.OffsetBy(offset);
}


void
MacDecorator::_ResizeBy(BPoint offset, BRegion* dirty)
{
	// Move all internal rectangles the appropriate amount
	fFrame.right += offset.x;
	fFrame.bottom += offset.y;

	fTitleBarRect.right += offset.x;
	fBorderRect.right += offset.x;
	fBorderRect.bottom += offset.y;
	// fZoomRect.OffsetBy(offset.x, 0);
	// fMinimizeRect.OffsetBy(offset.x, 0);
	if (dirty) {
		dirty->Include(fTitleBarRect);
		dirty->Include(fBorderRect);
	}

	// TODO probably some other layouting stuff here
	_DoLayout();
}


// TODO : _SetSettings


Decorator::Tab*
MacDecorator::_AllocateNewTab()
{
	Decorator::Tab* tab = new(std::nothrow) Decorator::Tab;
	if (tab == NULL)
		return NULL;

	// Set appropriate colors based on the current focus value. In this case,
	// each decorator defaults to not having the focus.
	_SetFocus(tab);
	return tab;
}


bool
MacDecorator::_AddTab(DesktopSettings& settings, int32 index,
	BRegion* updateRegion)
{
	_UpdateFont(settings);

	_DoLayout();
	if (updateRegion != NULL)
		updateRegion->Include(fTitleBarRect);
	return true;
}


bool
MacDecorator::_RemoveTab(int32 index, BRegion* updateRegion)
{
	BRect oldTitle = fTitleBarRect;
	_DoLayout();
	if (updateRegion != NULL) {
		updateRegion->Include(oldTitle);
		updateRegion->Include(fTitleBarRect);
	}
	return true;
}


bool
MacDecorator::_MoveTab(int32 from, int32 to, bool isMoving,
	BRegion* updateRegion)
{
	return false;

#if 0
	MacDecorator::Tab* toTab = _TabAt(to);
	if (toTab == NULL)
		return false;

	if (from < to) {
		fOldMovingTab.OffsetBy(toTab->tabRect.Width(), 0);
		toTab->tabRect.OffsetBy(-fOldMovingTab.Width(), 0);
	} else {
		fOldMovingTab.OffsetBy(-toTab->tabRect.Width(), 0);
		toTab->tabRect.OffsetBy(fOldMovingTab.Width(), 0);
	}

	toTab->tabOffset = uint32(toTab->tabRect.left - fLeftBorder.left);
	_LayoutTabItems(toTab, toTab->tabRect);

	_CalculateTabsRegion();

	if (updateRegion != NULL)
		updateRegion->Include(fTitleBarRect);
	return true;
#endif
}


void
MacDecorator::_GetFootprint(BRegion* region)
{
	// This function calculates the decorator's footprint in coordinates
	// relative to the view. This is most often used to set a Window
	// object's visible region.
	if (!region)
		return;

	region->MakeEmpty();

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

	region->Set(fBorderRect);
	region->Exclude(fFrame);

	if (fTopTab->look == B_BORDERED_WINDOW_LOOK)
		return;
	region->Include(fTitleBarRect);
}


void
MacDecorator::_UpdateFont(DesktopSettings& settings)
{
	ServerFont font;
	if (fTopTab && fTopTab->look == B_FLOATING_WINDOW_LOOK)
		settings.GetDefaultPlainFont(font);
	else
		settings.GetDefaultBoldFont(font);

	font.SetFlags(B_FORCE_ANTIALIASING);
	font.SetSpacing(B_STRING_SPACING);
	fDrawState.SetFont(font);
}


// #pragma mark - Private methods


// Draw a mac-style button
void
MacDecorator::_DrawButton(Decorator::Tab* tab, bool direct, BRect r,
	bool down)
{
	BRect rect(r);

	BPoint offset(r.LeftTop()), pt2(r.RightTop());

	// Topleft dark grey border
	pt2.x--;
	fDrawingEngine->SetHighColor(RGBColor(136, 136, 136));
	fDrawingEngine->StrokeLine(offset, pt2);

	pt2 = r.LeftBottom();
	pt2.y--;
	fDrawingEngine->StrokeLine(offset, pt2);

	// Bottomright white border
	offset = r.RightBottom();
	pt2 = r.RightTop();
	pt2.y++;
	fDrawingEngine->SetHighColor(RGBColor(255, 255, 255));
	fDrawingEngine->StrokeLine(offset, pt2);

	pt2 = r.LeftBottom();
	pt2.x++;
	fDrawingEngine->StrokeLine(offset, pt2);

	// Black outline
	rect.InsetBy(1, 1);
	fDrawingEngine->SetHighColor(RGBColor(33, 33, 33));
	fDrawingEngine->StrokeRect(rect);

	// Double-shaded button
	rect.InsetBy(1, 1);
	fDrawingEngine->SetHighColor(RGBColor(140, 140, 140));
	fDrawingEngine->StrokeLine(rect.RightBottom(), rect.RightTop());
	fDrawingEngine->StrokeLine(rect.RightBottom(), rect.LeftBottom());
	fDrawingEngine->SetHighColor(RGBColor(206, 206, 206));
	fDrawingEngine->StrokeLine(rect.LeftBottom(), rect.LeftTop());
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.RightTop());
	fDrawingEngine->SetHighColor(RGBColor(255, 255, 255));
	fDrawingEngine->StrokeLine(rect.LeftTop(), rect.LeftTop());

	rect.InsetBy(1, 1);
	_DrawBlendedRect(fDrawingEngine, rect, !down);
}


/*!	\brief Draws a rectangle with a gradient.
  \param down The rectangle should be drawn recessed or not
*/
void
MacDecorator::_DrawBlendedRect(DrawingEngine* engine, BRect rect,
	bool down/*, bool focus*/)
{
	// figure out which colors to use
	rgb_color startColor, endColor;
	if (down) {
		startColor = fButtonLowColor;
		endColor = fFrameHighColor;
	} else {
		startColor = fButtonHighColor;
		endColor = fFrameLowerColor;
	}

	// fill
	BGradientLinear gradient;
	gradient.SetStart(rect.LeftTop());
	gradient.SetEnd(rect.RightBottom());
	gradient.AddColor(startColor, 0);
	gradient.AddColor(endColor, 255);

	engine->FillRect(rect, gradient);
}


// #pragma mark - DecorAddOn


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