haiku.git

/*
Open Tracker License

Terms and Conditions

Copyright (c) 1991-2000, Be Incorporated. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice applies to all licensees
and shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of Be Incorporated shall not be
used in advertising or otherwise to promote the sale, use or other dealings in
this Software without prior written authorization from Be Incorporated.

Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered
trademarks of Be Incorporated in the United States and other countries. Other
brand product names are registered trademarks or trademarks of their respective
holders.
All rights reserved.
*/


#include "Switcher.h"

#include <float.h>
#include <stdlib.h>
#include <strings.h>

#include <Bitmap.h>
#include <ControlLook.h>
#include <Debug.h>
#include <Font.h>
#include <LayoutUtils.h>
#include <Mime.h>
#include <Node.h>
#include <NodeInfo.h>
#include <Roster.h>
#include <Screen.h>
#include <String.h>
#include <WindowInfo.h>

#include "BarApp.h"
#include "ResourceSet.h"
#include "WindowMenuItem.h"
#include "icons.h"
#include "tracker_private.h"


#define _ALLOW_STICKY_ 0
	// allows you to press 's' to keep the switcher window on screen


class TTeamGroup {
public:
							TTeamGroup();
							TTeamGroup(BList* teams, uint32 flags, char* name,
								const char* signature);
	virtual					~TTeamGroup();

			void			Draw(BView* view, BRect bounds, bool main);

			BList*			TeamList() const
								{ return fTeams; }
			const char*		Name() const
								{ return fName; }
			const char*		Signature() const
								{ return fSignature; }
			uint32			Flags() const
								{ return fFlags; }

			const BBitmap*	SmallIcon() const { return fSmallIcon; }
			const BBitmap*	LargeIcon() const { return fLargeIcon; }

			void			CacheTeamIcons(int32 small, int32 large);

private:
			BList*			fTeams;
			uint32			fFlags;
			char			fSignature[B_MIME_TYPE_LENGTH];
			char*			fName;

			BBitmap*		fSmallIcon;
			BBitmap*		fLargeIcon;
};

class TSwitcherWindow : public BWindow {
public:
							TSwitcherWindow(BRect frame,
								TSwitchManager* manager);
	virtual					~TSwitcherWindow();

	virtual bool			QuitRequested();
	virtual void			MessageReceived(BMessage* message);
	virtual void			ScreenChanged(BRect screenFrame, color_space);
	virtual void			Show();
	virtual void			Hide();
	virtual void			WindowActivated(bool state);
	virtual void			WorkspaceActivated(int32, bool active);

			void			DoKey(uint32 key, uint32 modifiers);
			TIconView*		IconView();
			TWindowView*	WindowView();
			TBox*			TopView();
			bool			HairTrigger();
			void			Update(int32 previous, int32 current,
								int32 prevSlot, int32 currentSlot,
								bool forward);
			int32			SlotOf(int32);
			void			Redraw(int32 index);

protected:
			void			CenterWindow(BRect screenFrame, BSize);

private:
			TSwitchManager*	fManager;
			TIconView*		fIconView;
			TBox*			fTopView;
			TWindowView*	fWindowView;
			bool			fHairTrigger;
			bool			fSkipKeyRepeats;
};

class TWindowView : public BView {
public:
							TWindowView(BRect frame, TSwitchManager* manager,
								TSwitcherWindow* switcher);

			void			UpdateGroup(int32 groupIndex, int32 windowIndex);

	virtual void			AttachedToWindow();
	virtual void			Draw(BRect update);
	virtual void			Pulse();
	virtual void			GetPreferredSize(float* w, float* h);
			void			ScrollTo(float x, float y)
							{
								ScrollTo(BPoint(x, y));
							}
	virtual void			ScrollTo(BPoint where);

			void			ShowIndex(int32 windex);
			BRect			FrameOf(int32 index) const;

private:
			int32			fCurrentToken;
			float			fItemHeight;
			TSwitcherWindow* fSwitcher;
			TSwitchManager*	fManager;
};

class TIconView : public BView {
public:
							TIconView(BRect frame, TSwitchManager* manager,
								TSwitcherWindow* switcher);
	virtual					~TIconView();

			void			Showing();
			void			Hiding();

	virtual void			KeyDown(const char* bytes, int32 numBytes);
	virtual void			Pulse();
	virtual void			MouseDown(BPoint point);
	virtual void			Draw(BRect updateRect);

			void			ScrollTo(float x, float y)
								{ ScrollTo(BPoint(x, y)); }
	virtual void			ScrollTo(BPoint where);

			void			Update(int32 previous, int32 current,
								int32 previousSlot, int32 currentSlot,
								bool forward);
			void			DrawTeams(BRect update);

			int32			SlotOf(int32) const;
			BRect			FrameOf(int32) const;
			int32			ItemAtPoint(BPoint) const;
			int32			IndexAt(int32 slot) const;
			void			CenterOn(int32 index);

private:
			void			AnimateIcon(const BBitmap* start, const BBitmap* end);

			bool			fAutoScrolling;
			TSwitcherWindow* fSwitcher;
			TSwitchManager*	fManager;
			BBitmap*		fOffBitmap;
			BView*			fOffView;
};

class TBox : public BBox {
public:
							TBox(BRect bounds, TSwitchManager* manager,
								TSwitcherWindow* window, TIconView* iconView);

	virtual void			Draw(BRect update);
	virtual void			AllAttached();
	virtual void			DrawIconScrollers(bool force);
	virtual void			DrawWindowScrollers(bool force);
	virtual void			MouseDown(BPoint where);

private:
			TSwitchManager*	fManager;
			TSwitcherWindow* fWindow;
			TIconView*		fIconView;
			BRect			fCenter;
			bool			fLeftScroller;
			bool			fRightScroller;
			bool			fUpScroller;
			bool			fDownScroller;
};


static const int32 kHorizontalMargin = 11;
static const int32 kVerticalMargin = 10;

static const int32 kTeamIconSize = 48;

static const int32 kWindowScrollSteps = 3;



//	#pragma mark -


static int32
LowBitIndex(uint32 value)
{
	int32 result = 0;
	int32 bitMask = 1;

	if (value == 0)
		return -1;

	while (result < 32 && (value & bitMask) == 0) {
		result++;
		bitMask = bitMask << 1;
	}
	return result;
}


inline bool
IsVisibleInCurrentWorkspace(const window_info* windowInfo)
{
	// The window list is always ordered from the top front visible window
	// (the first on the list), going down through all the other visible
	// windows, then all hidden or non-workspace visible windows at the end.
	//     layer > 2  : normal visible window
	//     layer == 2 : reserved for the desktop window (visible also)
	//     layer < 2  : hidden (0) and non workspace visible window (1)
	return windowInfo->layer > 2;
}


bool
IsKeyDown(int32 key)
{
	key_info keyInfo;

	get_key_info(&keyInfo);
	return (keyInfo.key_states[key >> 3] & (1 << ((7 - key) & 7))) != 0;
}


bool
IsWindowOK(const window_info* windowInfo)
{
	// is_mini (true means that the window is minimized).
	// if not, then show_hide >= 1 means that the window is hidden.
	// If the window is both minimized and hidden, then you get :
	//     TWindow->is_mini = false;
	//     TWindow->was_mini = true;
	//     TWindow->show_hide >= 1;

	if (windowInfo->feel != _STD_W_TYPE_)
		return false;

	if (windowInfo->is_mini)
		return true;

	return windowInfo->show_hide_level <= 0;
}


int
SmartStrcmp(const char* s1, const char* s2)
{
	if (strcasecmp(s1, s2) == 0)
		return 0;

	// if the strings on differ in spaces or underscores they still match
	while (*s1 && *s2) {
		if ((*s1 == ' ') || (*s1 == '_')) {
			s1++;
			continue;
		}
		if ((*s2 == ' ') || (*s2 == '_')) {
			s2++;
			continue;
		}
		if (*s1 != *s2) {
			// they differ
			return 1;
		}
		s1++;
		s2++;
	}

	// if one of the strings ended before the other
	// TODO: could process trailing spaces and underscores
	if (*s1)
		return 1;
	if (*s2)
		return 1;

	return 0;
}


//	#pragma mark - TTeamGroup


TTeamGroup::TTeamGroup()
	:
	fTeams(NULL),
	fFlags(0),
	fName(NULL),
	fSmallIcon(NULL),
	fLargeIcon(NULL)
{
	fSignature[0] = '\0';
}


TTeamGroup::TTeamGroup(BList* teams, uint32 flags, char* name,
		const char* signature)
	:
	fTeams(teams),
	fFlags(flags),
	fName(name),
	fSmallIcon(NULL),
	fLargeIcon(NULL)
{
	strlcpy(fSignature, signature, sizeof(fSignature));
}


TTeamGroup::~TTeamGroup()
{
	delete fTeams;
	free(fName);
}


void
TTeamGroup::Draw(BView* view, BRect bounds, bool main)
{
	BRect largeRect = fLargeIcon->Bounds();
	largeRect.OffsetTo(bounds.LeftTop());
	int32 offset = (bounds.IntegerWidth()
		- largeRect.IntegerWidth()) / 2;
	largeRect.OffsetBy(offset, offset);
	if (main)
		view->DrawBitmap(fLargeIcon, largeRect);
	else {
		BRect smallRect = fSmallIcon->Bounds();
		smallRect.OffsetTo(largeRect.LeftTop());
		int32 offset = (largeRect.IntegerWidth()
			- smallRect.IntegerWidth()) / 2;
		smallRect.OffsetBy(BPoint(offset, offset));
		view->DrawBitmap(fSmallIcon, smallRect);
	}
}


void
TTeamGroup::CacheTeamIcons(int32 smallIconSize, int32 largeIconSize)
{
	TBarApp* app = static_cast<TBarApp*>(be_app);
	int32 teamCount = TeamList()->CountItems();
	for (int32 index = 0; index < teamCount; index++) {
		team_id team = (addr_t)TeamList()->ItemAt(index);
		fSmallIcon = app->FetchTeamIcon(team, smallIconSize);
		fLargeIcon = app->FetchTeamIcon(team, largeIconSize);
	}
}


//	#pragma mark - TSwitchManager


TSwitchManager::TSwitchManager()
	: BHandler("SwitchManager"),
	fMainMonitor(create_sem(1, "main_monitor")),
	fBlock(false),
	fSkipUntil(0),
	fLastSwitch(0),
	fQuickSwitchIndex(-1),
	fQuickSwitchWindow(-1),
	fGroupList(10),
	fCurrentIndex(0),
	fCurrentSlot(0),
	fWindowID(-1)
{
	fLargeIconSize = kTeamIconSize;
	fSmallIconSize = kTeamIconSize / 2;

	// get the composed icon size for slot calculation but don't set it
	int32 composed = be_control_look->ComposeIconSize(kTeamIconSize)
		.IntegerWidth() + 1;

	// SLOT_SIZE must be divisible by 4. That's because of the scrolling
	// animation. If this needs to change then look at TIconView::Update()
	fSlotSize = (composed + composed / 4) & ~3u;
	fScrollStep = fSlotSize / 2;

	// TODO set these based on screen width
	fSlotCount = 7;
	fCenterSlot = 3;

	font_height plainFontHeight;
	be_plain_font->GetHeight(&plainFontHeight);
	float plainHeight = plainFontHeight.ascent + plainFontHeight.descent;

	BRect rect(0, 0,
		(fSlotSize * fSlotCount) - 1 + (2 * kHorizontalMargin),
		fSlotSize + (4 * kVerticalMargin) + plainHeight);
	fWindow = new TSwitcherWindow(rect, this);
	fWindow->AddHandler(this);

	fWindow->Lock();
	fWindow->Run();

	BList tmpList;
	TBarApp::Subscribe(BMessenger(this), &tmpList);

	for (int32 i = 0; ; i++) {
		BarTeamInfo* barTeamInfo = (BarTeamInfo*)tmpList.ItemAt(i);
		if (!barTeamInfo)
			break;

		TTeamGroup* group = new TTeamGroup(barTeamInfo->teams,
			barTeamInfo->flags, barTeamInfo->name, barTeamInfo->sig);
		group->CacheTeamIcons(fSmallIconSize, fLargeIconSize);
		fGroupList.AddItem(group);

		barTeamInfo->teams = NULL;
		barTeamInfo->name = NULL;

		delete barTeamInfo;
	}
	fWindow->Unlock();
}


TSwitchManager::~TSwitchManager()
{
	for (int32 i = fGroupList.CountItems() - 1; i >= 0; i--) {
		TTeamGroup* teamInfo = static_cast<TTeamGroup*>(fGroupList.ItemAt(i));
		delete teamInfo;
	}
}


void
TSwitchManager::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_SOME_APP_QUIT:
		{
			// This is only sent when last team of a matching set quits
			team_id teamID;
			int i = 0;
			TTeamGroup* tinfo;
			message->FindInt32("team", &teamID);

			while ((tinfo = (TTeamGroup*)fGroupList.ItemAt(i)) != NULL) {
				if (tinfo->TeamList()->HasItem((void*)(addr_t)teamID)) {
					fGroupList.RemoveItem(i);

					fWindow->Redraw(i);
					if (i <= fCurrentIndex) {
						fCurrentIndex--;
						CycleApp(true);
					}
					delete tinfo;
					break;
				}
				i++;
			}
			break;
		}

		case B_SOME_APP_LAUNCHED:
		{
			const char* name;
			uint32 flags;
			const char* signature;
			BList* teams;

			if (message->FindString("sig", &signature) != B_OK)
				break;

			if (message->FindInt32("flags", (int32*)&flags) != B_OK)
				break;

			if (message->FindString("name", &name) != B_OK)
				break;

			if (message->FindPointer("teams", (void**)&teams) != B_OK)
				break;

			TTeamGroup* group = new TTeamGroup(teams, flags, strdup(name),
				signature);
			group->CacheTeamIcons(fSmallIconSize, fLargeIconSize);
			fGroupList.AddItem(group);
			fWindow->Redraw(fGroupList.CountItems() - 1);
			break;
		}

		case kAddTeam:
		{
			team_id team = message->FindInt32("team");
			const char* signature = message->FindString("sig");

			int32 teamCount = fGroupList.CountItems();
			for (int32 index = 0; index < teamCount; index++) {
				TTeamGroup* group = (TTeamGroup*)fGroupList.ItemAt(index);
				ASSERT(group);
				if (strcasecmp(group->Signature(), signature) == 0
					&& !group->TeamList()->HasItem((void*)(addr_t)team)) {
					group->CacheTeamIcons(fSmallIconSize, fLargeIconSize);
					group->TeamList()->AddItem((void*)(addr_t)team);
				}
				break;
			}
			break;
		}

		case kRemoveTeam:
		{
			team_id team = message->FindInt32("team");
			int32 teamCount = fGroupList.CountItems();
			for (int32 index = 0; index < teamCount; index++) {
				TTeamGroup* group = (TTeamGroup*)fGroupList.ItemAt(index);
				ASSERT(group);
				if (group->TeamList()->HasItem((void*)(addr_t)team)) {
					group->TeamList()->RemoveItem((void*)(addr_t)team);
					break;
				}
			}
			break;
		}

		case 'TASK':
		{
			// The first TASK message calls MainEntry. Subsequent ones
			// call Process().
			bigtime_t time;
			message->FindInt64("when", (int64*)&time);

			// The fSkipUntil stuff can be removed once the new input_server
			// starts differentiating initial key_downs from KeyDowns generated
			// by auto-repeat. Until then the fSkipUntil stuff helps, but it
			// isn't perfect.
			if (time < fSkipUntil)
				break;

			status_t status = acquire_sem_etc(fMainMonitor, 1, B_TIMEOUT, 0);
			if (status != B_OK) {
				if (!fWindow->IsHidden() && !fBlock) {
					// Want to skip TASK msgs posted before the window
					// was made visible. Better UI feel if we do this.
					if (time > fSkipUntil) {
						uint32 modifiers = 0;
						message->FindInt32("modifiers", (int32*)&modifiers);
						int32 key = 0;
						message->FindInt32("key", &key);

						Process((modifiers & B_SHIFT_KEY) == 0, key == 0x11);
					}
				}
			} else
				MainEntry(message);

			break;
		}

		default:
			break;
	}
}


void
TSwitchManager::_SortApps()
{
	team_id* teams;
	int32 count;
	if (BPrivate::get_application_order(current_workspace(), &teams, &count)
		!= B_OK)
		return;

	BList groups;
	if (!groups.AddList(&fGroupList)) {
		free(teams);
		return;
	}

	fGroupList.MakeEmpty();

	for (int32 i = 0; i < count; i++) {
		// find team
		TTeamGroup* info = NULL;
		for (int32 j = 0; (info = (TTeamGroup*)groups.ItemAt(j)) != NULL; j++) {
			if (info->TeamList()->HasItem((void*)(addr_t)teams[i])) {
				groups.RemoveItem(j);
				break;
			}
		}

		if (info != NULL)
			fGroupList.AddItem(info);
	}

	fGroupList.AddList(&groups);
		// add the remaining entries
	free(teams);
}


void
TSwitchManager::MainEntry(BMessage* message)
{
	bigtime_t now = system_time();
	bigtime_t timeout = now + 180000;
		// The above delay has a good "feel" found by trial and error

	app_info appInfo;
	be_roster->GetActiveAppInfo(&appInfo);

	bool resetQuickSwitch = false;

	if (now > fLastSwitch + 400000) {
		_SortApps();
		resetQuickSwitch = true;
	}

	fLastSwitch = now;

	int32 index;
	fCurrentIndex = FindTeam(appInfo.team, &index) != NULL ? index : 0;

	if (resetQuickSwitch) {
		fQuickSwitchIndex = fCurrentIndex;
		fQuickSwitchWindow = fCurrentWindow;
	}

	int32 key;
	message->FindInt32("key", (int32*)&key);

	uint32 modifierKeys = 0;
	while (system_time() < timeout) {
		modifierKeys = modifiers();
		if (!IsKeyDown(key)) {
			QuickSwitch(message);
			return;
		}
		if ((modifierKeys & B_CONTROL_KEY) == 0) {
			QuickSwitch(message);
			return;
		}
		snooze(20000);
			// Must be a multiple of the delay used above
	}

	Process((modifierKeys & B_SHIFT_KEY) == 0, key == 0x11);
}


void
TSwitchManager::Stop(bool do_action, uint32)
{
	fWindow->Hide();
	if (do_action)
		ActivateApp(true, true);

	release_sem(fMainMonitor);
}


TTeamGroup*
TSwitchManager::FindTeam(team_id teamID, int32* index)
{
	int i = 0;
	TTeamGroup* info;
	while ((info = (TTeamGroup*)fGroupList.ItemAt(i)) != NULL) {
		if (info->TeamList()->HasItem((void*)(addr_t)teamID)) {
			*index = i;
			return info;
		}
		i++;
	}

	return NULL;
}


void
TSwitchManager::Process(bool forward, bool byWindow)
{
	bool hidden = false;
	if (fWindow->Lock()) {
		hidden = fWindow->IsHidden();
		fWindow->Unlock();
	}
	if (byWindow) {
		// If hidden we need to get things started by switching to correct app
		if (hidden)
			SwitchToApp(fCurrentIndex, fCurrentIndex, forward);
		CycleWindow(forward, true);
	} else
		CycleApp(forward, false);

	if (hidden) {
		// more auto keyrepeat code
		// Because of key repeats we don't want to respond to any extraneous
		// 'TASK' messages until the window is completely shown. So block here.
		// the WindowActivated hook function will unblock.
		fBlock = true;

		if (fWindow->Lock()) {
			BRect screenFrame = BScreen(B_MAIN_SCREEN_ID).Frame();
			BRect windowFrame = fWindow->Frame();

			if (!screenFrame.Contains(windowFrame)) {
				// center the window
				BPoint point((screenFrame.left + screenFrame.right) / 2,
					(screenFrame.top + screenFrame.bottom) / 2);

				point.x -= (windowFrame.Width() / 2);
				point.y -= (windowFrame.Height() / 2);
				fWindow->MoveTo(point);
			}

			fWindow->Show();
			fWindow->Unlock();
		}
	}
}


void
TSwitchManager::QuickSwitch(BMessage* message)
{
	uint32 modifiers = 0;
	message->FindInt32("modifiers", (int32*)&modifiers);
	int32 key = 0;
	message->FindInt32("key", &key);

	team_id team;
	if (message->FindInt32("team", &team) == B_OK) {
		bool forward = (modifiers & B_SHIFT_KEY) == 0;

		if (key == 0x11) {
			// TODO: add the same switch logic we have for apps!
			SwitchWindow(team, forward, true);
		} else {
			if (fQuickSwitchIndex >= 0) {
				// Switch to the first app inbetween to make it always the next
				// app to switch to after the quick switch.
				int32 current = fCurrentIndex;
				SwitchToApp(current, fQuickSwitchIndex, false);
				ActivateApp(false, false);

				fCurrentIndex = current;
			}

			CycleApp(forward, true);
		}
	}

	release_sem(fMainMonitor);
}


void
TSwitchManager::CycleWindow(bool forward, bool wrap)
{
	int32 max = CountWindows(fCurrentIndex);
	int32 prev = fCurrentWindow;
	int32 next = fCurrentWindow;

	if (forward) {
		next++;
		if (next >= max) {
			if (!wrap)
				return;
			next = 0;
		}
	} else {
		next--;
		if (next < 0) {
			if (!wrap)
				return;
			next = max - 1;
		}
	}
	fCurrentWindow = next;

	if (fCurrentWindow != prev)
		fWindow->WindowView()->ShowIndex(fCurrentWindow);
}


void
TSwitchManager::CycleApp(bool forward, bool activateNow)
{
	int32 startIndex = fCurrentIndex;

	if (_FindNextValidApp(forward)) {
		// if we're here then we found a good one
		SwitchToApp(startIndex, fCurrentIndex, forward);

		if (!activateNow)
			return;

		ActivateApp(false, false);
	}
}


bool
TSwitchManager::_FindNextValidApp(bool forward)
{
	if (fGroupList.IsEmpty())
		return false;

	int32 max = fGroupList.CountItems();
	if (forward) {
		fCurrentIndex++;
		if (fCurrentIndex >= max)
			fCurrentIndex = 0;
	} else {
		fCurrentIndex--;
		if (fCurrentIndex < 0)
			fCurrentIndex = max - 1;
	}

	return true;
}


void
TSwitchManager::SwitchToApp(int32 previous, int32 current, bool forward)
{
	int32 previousSlot = fCurrentSlot;

	fCurrentIndex = current;
	fCurrentSlot = fWindow->SlotOf(fCurrentIndex);
	fCurrentWindow = 0;

	fWindow->Update(previous, fCurrentIndex, previousSlot, fCurrentSlot,
		forward);
}


bool
TSwitchManager::ActivateApp(bool forceShow, bool allowWorkspaceSwitch)
{
	// Let's get the info about the selected window. If it doesn't exist
	// anymore then get info about first window. If that doesn't exist then
	// do nothing.
	client_window_info* windowInfo = WindowInfo(fCurrentIndex, fCurrentWindow);
	if (windowInfo == NULL) {
		windowInfo = WindowInfo(fCurrentIndex, 0);
		if (windowInfo == NULL)
			return false;
	}

	int32 currentWorkspace = current_workspace();
	TTeamGroup* teamGroup = (TTeamGroup*)fGroupList.ItemAt(fCurrentIndex);

	// Let's handle the easy case first: There's only 1 team in the group
	if (teamGroup->TeamList()->CountItems() == 1) {
		bool result;
		if (forceShow && (fCurrentWindow != 0 || windowInfo->is_mini)) {
			do_window_action(windowInfo->server_token, B_BRING_TO_FRONT,
				BRect(0, 0, 0, 0), false);
		}

		if (!forceShow && windowInfo->is_mini) {
			// we aren't unhiding minimized windows, so we can't do
			// anything here
			result = false;
		} else if (!allowWorkspaceSwitch
			&& (windowInfo->workspaces & (1 << currentWorkspace)) == 0) {
			// we're not supposed to switch workspaces so abort.
			result = false;
		} else {
			result = true;
			be_roster->ActivateApp((addr_t)teamGroup->TeamList()->ItemAt(0));
		}

		ASSERT(windowInfo);
		free(windowInfo);
		return result;
	}

	// Now the trickier case. We're trying to Bring to the Front a group
	// of teams. The current window (defined by fCurrentWindow) will define
	// which workspace we're going to. Then, once that is determined we
	// want to bring to the front every window of the group of teams that
	// lives in that workspace.

	if ((windowInfo->workspaces & (1 << currentWorkspace)) == 0) {
		if (!allowWorkspaceSwitch) {
			// If the first window in the list isn't in current workspace,
			// then none are. So we can't switch to this app.
			ASSERT(windowInfo);
			free(windowInfo);
			return false;
		}
		int32 destWorkspace = LowBitIndex(windowInfo->workspaces);
		// now switch to that workspace
		activate_workspace(destWorkspace);
	}

	if (!forceShow && windowInfo->is_mini) {
		// If the first window in the list is hidden then no windows in
		// this group are visible. So we can't switch to this app.
		ASSERT(windowInfo);
		free(windowInfo);
		return false;
	}

	int32 tokenCount;
	int32* tokens = get_token_list(-1, &tokenCount);
	if (tokens == NULL) {
		ASSERT(windowInfo);
		free(windowInfo);
		return true;
			// weird error, so don't try to recover
	}

	BList windowsToActivate;

	// Now we go through all the windows in the current workspace list in order.
	// As we hit member teams we build the "activate" list.
	for (int32 i = 0; i < tokenCount; i++) {
		client_window_info* matchWindowInfo = get_window_info(tokens[i]);
		if (!matchWindowInfo) {
			// That window probably closed. Just go to the next one.
			continue;
		}
		if (!IsVisibleInCurrentWorkspace(matchWindowInfo)) {
			// first non-visible in workspace window means we're done.
			free(matchWindowInfo);
			break;
		}
		if (matchWindowInfo->server_token != windowInfo->server_token
			&& teamGroup->TeamList()->HasItem(
				(void*)(addr_t)matchWindowInfo->team))
			windowsToActivate.AddItem(
				(void*)(addr_t)matchWindowInfo->server_token);

		free(matchWindowInfo);
	}

	free(tokens);

	// Want to go through the list backwards to keep windows in same relative
	// order.
	int32 i = windowsToActivate.CountItems() - 1;
	for (; i >= 0; i--) {
		int32 wid = (addr_t)windowsToActivate.ItemAt(i);
		do_window_action(wid, B_BRING_TO_FRONT, BRect(0, 0, 0, 0), false);
	}

	// now bring the select window on top of everything.

	do_window_action(windowInfo->server_token, B_BRING_TO_FRONT,
		BRect(0, 0, 0, 0), false);

	free(windowInfo);
	return true;
}


/*!
	\brief quit all teams in this group
*/
void
TSwitchManager::QuitApp()
{
	// we should not be trying to quit an app if we have an empty list
	if (fGroupList.IsEmpty())
		return;

	TTeamGroup* teamGroup = (TTeamGroup*)fGroupList.ItemAt(fCurrentIndex);
	if (fCurrentIndex == fGroupList.CountItems() - 1) {
		// if we're in the last slot already (the last usable team group)
		// switch to previous app in the list so that we don't jump to
		// the start of the list (try to keep the same position when
		// the apps at the current index go away)
		CycleApp(false, false);
	}

	// send the quit request to all teams in this group
	for (int32 i = teamGroup->TeamList()->CountItems() - 1; i >= 0; i--) {
		team_id team = (addr_t)teamGroup->TeamList()->ItemAt(i);
		app_info info;
		if (be_roster->GetRunningAppInfo(team, &info) == B_OK) {
			if (strcasecmp(info.signature, kTrackerSignature) == 0) {
				// Tracker can't be quit this way
				continue;
			}

			BMessenger messenger(NULL, team);
			messenger.SendMessage(B_QUIT_REQUESTED);
		}
	}
}


/*!
	\brief hide all teams in this group
*/
void
TSwitchManager::HideApp()
{
	// we should not be trying to hide an app if we have an empty list
	if (fGroupList.IsEmpty())
		return;

	TTeamGroup* teamGroup = (TTeamGroup*)fGroupList.ItemAt(fCurrentIndex);

	for (int32 i = teamGroup->TeamList()->CountItems() - 1; i >= 0; i--) {
		team_id team = (addr_t)teamGroup->TeamList()->ItemAt(i);
		app_info info;
		if (be_roster->GetRunningAppInfo(team, &info) == B_OK)
			do_minimize_team(BRect(), team, false);
	}
}


client_window_info*
TSwitchManager::WindowInfo(int32 groupIndex, int32 windowIndex)
{
	TTeamGroup* teamGroup = (TTeamGroup*)fGroupList.ItemAt(groupIndex);
	if (teamGroup == NULL)
		return NULL;

	int32 tokenCount;
	int32* tokens = get_token_list(-1, &tokenCount);
	if (tokens == NULL)
		return NULL;

	int32 matches = 0;

	// Want to find the "windowIndex'th" window in window order that belongs
	// the the specified group (groupIndex). Since multiple teams can belong to
	// the same group (multiple-launch apps) we get the list of _every_
	// window and go from there.

	client_window_info* result = NULL;
	for (int32 i = 0; i < tokenCount; i++) {
		client_window_info* windowInfo = get_window_info(tokens[i]);
		if (windowInfo) {
			// skip hidden/special windows
			if (IsWindowOK(windowInfo) && (teamGroup->TeamList()->HasItem(
					(void*)(addr_t)windowInfo->team))) {
				// this window belongs to the team!
				if (matches == windowIndex) {
					// we found it!
					result = windowInfo;
					break;
				}
				matches++;
			}
			free(windowInfo);
		}
		// else - that window probably closed. Just go to the next one.
	}

	free(tokens);

	return result;
}


int32
TSwitchManager::CountWindows(int32 groupIndex, bool )
{
	TTeamGroup* teamGroup = (TTeamGroup*)fGroupList.ItemAt(groupIndex);
	if (teamGroup == NULL)
		return 0;

	int32 result = 0;

	for (int32 i = 0; ; i++) {
		team_id	teamID = (addr_t)teamGroup->TeamList()->ItemAt(i);
		if (teamID == 0)
			break;

		int32 count;
		int32* tokens = get_token_list(teamID, &count);
		if (!tokens)
			continue;

		for (int32 i = 0; i < count; i++) {
			window_info	*windowInfo = get_window_info(tokens[i]);
			if (windowInfo) {
				if (IsWindowOK(windowInfo))
					result++;
				free(windowInfo);
			}
		}
		free(tokens);
	}

	return result;
}


void
TSwitchManager::ActivateWindow(int32 windowID)
{
	if (windowID == -1)
		windowID = fWindowID;

	do_window_action(windowID, B_BRING_TO_FRONT, BRect(0, 0, 0, 0), false);
}


void
TSwitchManager::SwitchWindow(team_id team, bool, bool activate)
{
	// Find the _last_ window in the current workspace that belongs
	// to the group. This is the window to activate.

	int32 index;
	TTeamGroup* teamGroup = FindTeam(team, &index);
	if (teamGroup == NULL)
		return;

	// cycle through the windows in the active application
	int32 count;
	int32* tokens = get_token_list(-1, &count);
	if (tokens == NULL)
		return;

	for (int32 i = count - 1; i >= 0; i--) {
		client_window_info* windowInfo = get_window_info(tokens[i]);
		if (windowInfo && IsVisibleInCurrentWorkspace(windowInfo)
			&& teamGroup->TeamList()->HasItem((void*)(addr_t)windowInfo->team)) {
			fWindowID = windowInfo->server_token;
			if (activate)
				ActivateWindow(windowInfo->server_token);

			free(windowInfo);
			break;
		}
		free(windowInfo);
	}
	free(tokens);
}


void
TSwitchManager::Unblock()
{
	fBlock = false;
	fSkipUntil = system_time();
}


int32
TSwitchManager::CurrentIndex()
{
	return fCurrentIndex;
}


int32
TSwitchManager::CurrentWindow()
{
	return fCurrentWindow;
}


int32
TSwitchManager::CurrentSlot()
{
	return fCurrentSlot;
}


BList*
TSwitchManager::GroupList()
{
	return &fGroupList;
}


BRect
TSwitchManager::CenterRect()
{
	return BRect(fCenterSlot * fSlotSize, 0,
		(fCenterSlot + 1) * fSlotSize - 1, fSlotSize - 1);
}


//	#pragma mark - TBox


TBox::TBox(BRect bounds, TSwitchManager* manager, TSwitcherWindow* window,
		TIconView* iconView)
	:
	BBox(bounds, "top", B_FOLLOW_ALL, B_WILL_DRAW, B_NO_BORDER),
	fManager(manager),
	fWindow(window),
	fIconView(iconView),
	fLeftScroller(false),
	fRightScroller(false),
	fUpScroller(false),
	fDownScroller(false)
{
}


void
TBox::AllAttached()
{
	BRect centerRect(fManager->CenterRect());
	BRect frame = fIconView->Frame();

	// scroll the centerRect to correct location
	centerRect.OffsetBy(frame.left, frame.top);

	// switch to local coords
	fIconView->ConvertToParent(&centerRect);

	fCenter = centerRect;
}


void
TBox::MouseDown(BPoint where)
{
	if (!fLeftScroller && !fRightScroller && !fUpScroller && !fDownScroller)
		return;

	BRect frame = fIconView->Frame();
	BRect bounds = Bounds();

	if (fLeftScroller) {
		BRect lhit(0, frame.top, frame.left, frame.bottom);
		if (lhit.Contains(where)) {
			// Want to scroll by NUMSLOTS - 1 slots
			int32 previousIndex = fManager->CurrentIndex();
			int32 previousSlot = fManager->CurrentSlot();
			int32 newSlot = previousSlot - (fManager->SlotCount() - 1);
			if (newSlot < 0)
				newSlot = 0;

			int32 newIndex = fIconView->IndexAt(newSlot);
			fManager->SwitchToApp(previousIndex, newIndex, false);
		}
	}

	if (fRightScroller) {
		BRect rhit(frame.right, frame.top, bounds.right, frame.bottom);
		if (rhit.Contains(where)) {
			// Want to scroll by NUMSLOTS - 1 slots
			int32 previousIndex = fManager->CurrentIndex();
			int32 previousSlot = fManager->CurrentSlot();
			int32 newSlot = previousSlot + (fManager->SlotCount() - 1);
			int32 newIndex = fIconView->IndexAt(newSlot);

			if (newIndex < 0) {
				// don't have a page full to scroll
				newIndex = fManager->GroupList()->CountItems() - 1;
			}
			fManager->SwitchToApp(previousIndex, newIndex, true);
		}
	}

	frame = fWindow->WindowView()->Frame();
	if (fUpScroller) {
		BRect hit1(frame.left - 10, frame.top, frame.left,
			(frame.top + frame.bottom) / 2);
		BRect hit2(frame.right, frame.top, frame.right + 10,
			(frame.top + frame.bottom) / 2);
		if (hit1.Contains(where) || hit2.Contains(where)) {
			// Want to scroll up 1 window
			fManager->CycleWindow(false, false);
		}
	}

	if (fDownScroller) {
		BRect hit1(frame.left - 10, (frame.top + frame.bottom) / 2,
			frame.left, frame.bottom);
		BRect hit2(frame.right, (frame.top + frame.bottom) / 2,
			frame.right + 10, frame.bottom);
		if (hit1.Contains(where) || hit2.Contains(where)) {
			// Want to scroll down 1 window
			fManager->CycleWindow(true, false);
		}
	}
}


void
TBox::Draw(BRect update)
{
	static const int32 kChildInset = 7;
	static const int32 kWedge = 6;

	BBox::Draw(update);

	// The fancy border around the icon view

	BRect bounds = Bounds();
	float height = fIconView->Bounds().Height();
	float center = (bounds.right + bounds.left) / 2;

	BRect box(3, 3, bounds.right - 3, 3 + height + kChildInset * 2);
	rgb_color panelColor = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color white = {255, 255, 255, 255};
	rgb_color standardGray = panelColor;
	rgb_color veryDarkGray = {128, 128, 128, 255};
	rgb_color darkGray = tint_color(panelColor, B_DARKEN_1_TINT);

	if (panelColor.IsDark()) {
		standardGray = tint_color(panelColor, 0.8);
		darkGray = tint_color(panelColor, 0.85);
		white = make_color(200, 200, 200, 255);
		veryDarkGray = make_color(0, 0, 0, 255);
	}

	// Fill the area with dark gray
	SetHighColor(darkGray);
	box.InsetBy(1, 1);
	FillRect(box);

	box.InsetBy(-1, -1);

	BeginLineArray(50);

	// The main frame around the icon view
	AddLine(box.LeftTop(), BPoint(center - kWedge, box.top), veryDarkGray);
	AddLine(BPoint(center + kWedge, box.top), box.RightTop(), veryDarkGray);

	AddLine(box.LeftBottom(), BPoint(center - kWedge, box.bottom),
		veryDarkGray);
	AddLine(BPoint(center + kWedge, box.bottom), box.RightBottom(),
		veryDarkGray);
	AddLine(box.LeftBottom() + BPoint(1, 1),
		BPoint(center - kWedge, box.bottom + 1), white);
	AddLine(BPoint(center + kWedge, box.bottom) + BPoint(0, 1),
		box.RightBottom() + BPoint(1, 1), white);

	AddLine(box.LeftTop(), box.LeftBottom(), veryDarkGray);
	AddLine(box.RightTop(), box.RightBottom(), veryDarkGray);
	AddLine(box.RightTop() + BPoint(1, 1), box.RightBottom() + BPoint(1, 1),
		white);

	// downward pointing area at top of frame
	BPoint point(center - kWedge, box.top);
	AddLine(point, point + BPoint(kWedge, kWedge), veryDarkGray);
	AddLine(point + BPoint(kWedge, kWedge), BPoint(center + kWedge, point.y),
		veryDarkGray);

	AddLine(point + BPoint(1, 0), point + BPoint(1, 0)
		+ BPoint(kWedge - 1, kWedge - 1), white);

	AddLine(point + BPoint(2, -1) + BPoint(kWedge - 1, kWedge - 1),
		BPoint(center + kWedge - 1, point.y), darkGray);

	BPoint topPoint = point;

	// upward pointing area at bottom of frame
	point.y = box.bottom;
	point.x = center - kWedge;
	AddLine(point, point + BPoint(kWedge, -kWedge), veryDarkGray);
	AddLine(point + BPoint(kWedge, -kWedge),
		BPoint(center + kWedge, point.y), veryDarkGray);

	AddLine(point + BPoint(1, 0),
		point + BPoint(1, 0) + BPoint(kWedge - 1, -(kWedge - 1)), white);

	AddLine(point + BPoint(2 , 1) + BPoint(kWedge - 1, -(kWedge - 1)),
		BPoint(center + kWedge - 1, point.y), darkGray);

	BPoint bottomPoint = point;

	EndLineArray();

	// fill the downward pointing arrow area
	SetHighColor(standardGray);
	FillTriangle(topPoint + BPoint(2, 0),
		topPoint + BPoint(2, 0) + BPoint(kWedge - 2, kWedge - 2),
		BPoint(center + kWedge - 2, topPoint.y));

	// fill the upward pointing arrow area
	SetHighColor(standardGray);
	FillTriangle(bottomPoint + BPoint(2, 0),
		bottomPoint + BPoint(2, 0) + BPoint(kWedge - 2, -(kWedge - 2)),
		BPoint(center + kWedge - 2, bottomPoint.y));

	DrawIconScrollers(false);
	DrawWindowScrollers(false);

}


void
TBox::DrawIconScrollers(bool force)
{
	rgb_color panelColor = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color backgroundColor;
	rgb_color dark;

	if (panelColor.IsLight()) {
		backgroundColor = tint_color(panelColor, B_DARKEN_1_TINT);
		dark = tint_color(backgroundColor, B_DARKEN_3_TINT);
	} else {
		backgroundColor = tint_color(panelColor, 0.85);
		dark = tint_color(panelColor, B_LIGHTEN_1_TINT);
	}

	bool updateLeft = false;
	bool updateRight = false;

	BRect rect = fIconView->Bounds();
	if (rect.left > (fManager->SlotSize() * fManager->CenterSlot())) {
		updateLeft = true;
		fLeftScroller = true;
	} else {
		fLeftScroller = false;
		if (force)
			updateLeft = true;
	}

	int32 maxIndex = fManager->GroupList()->CountItems() - 1;
	// last_frame is in fIconView coordinate space
	BRect lastFrame = fIconView->FrameOf(maxIndex);

	if (lastFrame.right > rect.right) {
		updateRight = true;
		fRightScroller = true;
	} else {
		fRightScroller = false;
		if (force)
			updateRight = true;
	}

	PushState();
	SetDrawingMode(B_OP_COPY);

	rect = fIconView->Frame();
	if (updateLeft) {
		BPoint pt1, pt2, pt3;
		pt1.x = rect.left - 5;
		pt1.y = floorf((rect.bottom + rect.top) / 2);
		pt2.x = pt3.x = pt1.x + 3;
		pt2.y = pt1.y - 3;
		pt3.y = pt1.y + 3;

		if (fLeftScroller) {
			SetHighColor(dark);
			FillTriangle(pt1, pt2, pt3);
		} else if (force) {
			SetHighColor(backgroundColor);
			FillRect(BRect(pt1.x, pt2.y, pt3.x, pt3.y));
		}
	}
	if (updateRight) {
		BPoint pt1, pt2, pt3;
		pt1.x = rect.right + 4;
		pt1.y = rintf((rect.bottom + rect.top) / 2);
		pt2.x = pt3.x = pt1.x - 4;
		pt2.y = pt1.y - 4;
		pt3.y = pt1.y + 4;

		if (fRightScroller) {
			SetHighColor(dark);
			FillTriangle(pt1, pt2, pt3);
		} else if (force) {
			SetHighColor(backgroundColor);
			FillRect(BRect(pt3.x, pt2.y, pt1.x, pt3.y));
		}
	}

	PopState();
}


void
TBox::DrawWindowScrollers(bool force)
{
	rgb_color panelColor = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color backgroundColor;
	rgb_color dark;

	if (panelColor.IsLight()) {
		backgroundColor = tint_color(panelColor, B_DARKEN_1_TINT);
		dark = tint_color(backgroundColor, B_DARKEN_2_TINT);
	} else {
		backgroundColor = panelColor;
		dark = tint_color(panelColor, B_LIGHTEN_2_TINT);
	}

	bool updateUp = false;
	bool updateDown = false;

	BRect rect = fWindow->WindowView()->Bounds();
	if (rect.top != 0) {
		updateUp = true;
		fUpScroller = true;
	} else {
		fUpScroller = false;
		if (force)
			updateUp = true;
	}

	int32 groupIndex = fManager->CurrentIndex();
	int32 maxIndex = fManager->CountWindows(groupIndex) - 1;

	BRect lastFrame(0, 0, 0, 0);
	if (maxIndex >= 0)
		lastFrame = fWindow->WindowView()->FrameOf(maxIndex);

	if (maxIndex >= 0 && lastFrame.bottom > rect.bottom) {
		updateDown = true;
		fDownScroller = true;
	} else {
		fDownScroller = false;
		if (force)
			updateDown = true;
	}

	PushState();
	SetDrawingMode(B_OP_COPY);

	rect = fWindow->WindowView()->Frame();
	rect.InsetBy(-3, 0);
	if (updateUp) {
		if (fUpScroller) {
			SetHighColor(dark);
			BPoint pt1, pt2, pt3;
			pt1.x = rect.left - 6;
			pt1.y = rect.top + 3;
			pt2.y = pt3.y = pt1.y + 4;
			pt2.x = pt1.x - 4;
			pt3.x = pt1.x + 4;
			FillTriangle(pt1, pt2, pt3);

			pt1.x += rect.Width() + 12;
			pt2.x += rect.Width() + 12;
			pt3.x += rect.Width() + 12;
			FillTriangle(pt1, pt2, pt3);
		} else if (force) {
			FillRect(BRect(rect.left - 10, rect.top + 3, rect.left - 2,
				rect.top + 7), B_SOLID_LOW);
			FillRect(BRect(rect.right + 2, rect.top + 3, rect.right + 10,
				rect.top + 7), B_SOLID_LOW);
		}
	}
	if (updateDown) {
		if (fDownScroller) {
			SetHighColor(dark);
			BPoint pt1, pt2, pt3;
			pt1.x = rect.left - 6;
			pt1.y = rect.bottom - 3;
			pt2.y = pt3.y = pt1.y - 4;
			pt2.x = pt1.x - 4;
			pt3.x = pt1.x + 4;
			FillTriangle(pt1, pt2, pt3);

			pt1.x += rect.Width() + 12;
			pt2.x += rect.Width() + 12;
			pt3.x += rect.Width() + 12;
			FillTriangle(pt1, pt2, pt3);
		} else if (force) {
			FillRect(BRect(rect.left - 10, rect.bottom - 7, rect.left - 2,
				rect.bottom - 3), B_SOLID_LOW);
			FillRect(BRect(rect.right + 2, rect.bottom - 7, rect.right + 10,
				rect.bottom - 3), B_SOLID_LOW);
		}
	}

	PopState();
	Sync();
}


//	#pragma mark - TSwitcherWindow


TSwitcherWindow::TSwitcherWindow(BRect frame, TSwitchManager* manager)
	:
	BWindow(frame, "Twitcher", B_MODAL_WINDOW_LOOK, B_MODAL_ALL_WINDOW_FEEL,
		B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE | B_NOT_RESIZABLE, B_ALL_WORKSPACES),
	fManager(manager),
	fHairTrigger(true)
{
	BRect rect = frame;
	rect.OffsetTo(B_ORIGIN);
	rect.InsetBy(kHorizontalMargin, 0);
	rect.top = kVerticalMargin;
	rect.bottom = rect.top + fManager->SlotSize() + 1;

	fIconView = new TIconView(rect, manager, this);

	rect.top = rect.bottom + (kVerticalMargin * 1 + 4);
	rect.InsetBy(9, 0);

	fWindowView = new TWindowView(rect, manager, this);
	fWindowView->ResizeToPreferred();

	fTopView = new TBox(Bounds(), fManager, this, fIconView);
	AddChild(fTopView);
	fTopView->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	fTopView->SetLowUIColor(B_PANEL_BACKGROUND_COLOR);
	fTopView->SetHighUIColor(B_PANEL_TEXT_COLOR);

	SetPulseRate(0);
	fTopView->AddChild(fIconView);
	fTopView->AddChild(fWindowView);

	if (be_plain_font->Size() != 12) {
		float sizeDelta = be_plain_font->Size() - 12;
		ResizeBy(0, sizeDelta);
	}

	CenterWindow(BScreen(B_MAIN_SCREEN_ID).Frame(), frame.Size());
}


TSwitcherWindow::~TSwitcherWindow()
{
}


void
TSwitcherWindow::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_UNMAPPED_KEY_DOWN:
		case B_KEY_DOWN:
		{
			int32 repeats = 0;
			if (message->FindInt32("be:key_repeat", &repeats) == B_OK
				&& (fSkipKeyRepeats || (repeats % 6) != 0))
				break;

			// The first actual key press let's us listening to repeated keys
			fSkipKeyRepeats = false;

			uint32 rawChar;
			uint32 modifiers;
			message->FindInt32("raw_char", 0, (int32*)&rawChar);
			message->FindInt32("modifiers", 0, (int32*)&modifiers);
			DoKey(rawChar, modifiers);
			break;
		}

		default:
			BWindow::MessageReceived(message);
	}
}


void
TSwitcherWindow::ScreenChanged(BRect screenFrame, color_space)
{
	CenterWindow(screenFrame | BScreen(B_MAIN_SCREEN_ID).Frame(),
		Frame().Size());
}


void
TSwitcherWindow::WorkspaceActivated(int32, bool active)
{
	if (active)
		CenterWindow(BScreen(B_MAIN_SCREEN_ID).Frame(), Frame().Size());
}


void
TSwitcherWindow::CenterWindow(BRect screenFrame, BSize windowSize)
{
	BPoint centered = BLayoutUtils::AlignInFrame(screenFrame, windowSize,
		BAlignment(B_ALIGN_HORIZONTAL_CENTER, B_ALIGN_VERTICAL_CENTER))
			.LeftTop();
	centered.y -= roundf(screenFrame.Height() / 16);

	MoveTo(centered);
}


void
TSwitcherWindow::Redraw(int32 index)
{
	BRect frame = fIconView->FrameOf(index);
	frame.right = fIconView->Bounds().right;
	fIconView->Invalidate(frame);
}


void
TSwitcherWindow::DoKey(uint32 key, uint32 modifiers)
{
	bool forward = ((modifiers & B_SHIFT_KEY) == 0);

	switch (key) {
		case B_RIGHT_ARROW:
			fManager->CycleApp(true, false);
			break;

		case B_LEFT_ARROW:
		case '1':
			fManager->CycleApp(false, false);
			break;

		case B_UP_ARROW:
			fManager->CycleWindow(false, false);
			break;

		case B_DOWN_ARROW:
			fManager->CycleWindow(true, false);
			break;

		case B_TAB:
			fManager->CycleApp(forward, false);
			break;

		case B_ESCAPE:
			fManager->Stop(false, 0);
			break;

		case B_SPACE:
		case B_ENTER:
			fManager->Stop(true, modifiers);
			break;

		case 'q':
		case 'Q':
			fManager->QuitApp();
			break;

		case 'h':
		case 'H':
			fManager->HideApp();
			break;

#if _ALLOW_STICKY_
		case 's':
		case 'S':
			if (fHairTrigger) {
				SetLook(B_TITLED_WINDOW_LOOK);
				fHairTrigger = false;
			} else {
				SetLook(B_MODAL_WINDOW_LOOK);
				fHairTrigger = true;
			}
			break;
#endif
	}
}


bool
TSwitcherWindow::QuitRequested()
{
	fManager->Stop(false, 0);
	return false;
}


void
TSwitcherWindow::WindowActivated(bool state)
{
	if (state)
		fManager->Unblock();
}


void
TSwitcherWindow::Update(int32 previous, int32 current,
	int32 previousSlot, int32 currentSlot, bool forward)
{
	if (!IsHidden()) {
		fIconView->Update(previous, current, previousSlot, currentSlot,
			forward);
	} else
		fIconView->CenterOn(current);

	fWindowView->UpdateGroup(current, 0);
}


void
TSwitcherWindow::Hide()
{
	fIconView->Hiding();
	SetPulseRate(0);
	BWindow::Hide();
}


void
TSwitcherWindow::Show()
{
	fHairTrigger = true;
	fSkipKeyRepeats = true;
	fIconView->Showing();
	SetPulseRate(100000);
	SetLook(B_MODAL_WINDOW_LOOK);
	BWindow::Show();
}


TBox*
TSwitcherWindow::TopView()
{
	return fTopView;
}


bool
TSwitcherWindow::HairTrigger()
{
	return fHairTrigger;
}


inline int32
TSwitcherWindow::SlotOf(int32 i)
{
	return fIconView->SlotOf(i);
}


inline TIconView*
TSwitcherWindow::IconView()
{
	return fIconView;
}


inline TWindowView*
TSwitcherWindow::WindowView()
{
	return fWindowView;
}


//	#pragma mark - TIconView


TIconView::TIconView(BRect frame, TSwitchManager* manager,
	TSwitcherWindow* switcherWindow)
	: BView(frame, "main_view", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED),
	fAutoScrolling(false),
	fSwitcher(switcherWindow),
	fManager(manager),
	fOffBitmap(NULL),
	fOffView(NULL)
{
	BRect slot(0, 0, fManager->SlotSize() - 1, fManager->SlotSize() - 1);

	fOffView = new BView(slot, "off_view", B_FOLLOW_NONE, B_WILL_DRAW);
	fOffBitmap = new BBitmap(slot, B_RGBA32, true);
	fOffBitmap->AddChild(fOffView);
}


TIconView::~TIconView()
{
}


void
TIconView::KeyDown(const char* /*bytes*/, int32 /*numBytes*/)
{
}


void
TIconView::AnimateIcon(const BBitmap* start, const BBitmap* end)
{
	BRect centerRect(fManager->CenterRect());
	BRect bounds = Bounds();
	float off = 0;

	BRect startRect = start->Bounds();
	BRect endRect = end->Bounds();
	BRect rect = startRect;
	int32 small = fManager->SmallIconSize();
	bool out = startRect.Width() <= small;
	int32 insetValue = small / 8;
	int32 inset = out ? -insetValue : insetValue;

	// center start rect in center rect
	off = roundf((centerRect.Width() - rect.Width()) / 2);
	startRect.OffsetTo(off, off);
	rect.OffsetTo(off, off);

	// center end rect in center rect
	off = roundf((centerRect.Width() - endRect.Width()) / 2);
	endRect.OffsetTo(off, off);

	// scroll center rect to the draw slot
	centerRect.OffsetBy(bounds.left, 0);

	// scroll dest rect to draw slow
	BRect destRect = fOffBitmap->Bounds();
	destRect.OffsetTo(centerRect.left, 0);

	// center dest rect in center rect
	off = roundf((centerRect.Width() - destRect.Width()) / 2);
	destRect.OffsetBy(off, off);

	fOffBitmap->Lock();

	rgb_color bg = ui_color(B_PANEL_BACKGROUND_COLOR);
	fOffView->SetHighColor(tint_color(bg, bg.IsLight() ? B_DARKEN_1_TINT : 0.85));

	// animate start icon
	for (int i = 0; i < 2; i++) {
		rect.InsetBy(inset, inset);
		snooze(20000);
		fOffView->SetDrawingMode(B_OP_COPY);
		fOffView->FillRect(fOffView->Bounds());
		fOffView->SetDrawingMode(B_OP_ALPHA);
		fOffView->DrawBitmap(start, rect);
		fOffView->Sync();
		DrawBitmap(fOffBitmap, destRect);
	}

	// draw cached start icon again to clear composed icon rounding errors
	fOffView->SetDrawingMode(B_OP_COPY);
	fOffView->FillRect(fOffView->Bounds());
	fOffView->SetDrawingMode(B_OP_ALPHA);
	fOffView->DrawBitmap(start, startRect);
	fOffView->Sync();
	DrawBitmap(fOffBitmap, destRect);

	// animate end icon
	for (int i = 0; i < 2; i++) {
		rect.InsetBy(inset, inset);
		snooze(20000);
		fOffView->SetDrawingMode(B_OP_COPY);
		fOffView->FillRect(fOffView->Bounds());
		fOffView->SetDrawingMode(B_OP_ALPHA);
		fOffView->DrawBitmap(end, rect);
		fOffView->Sync();
		DrawBitmap(fOffBitmap, destRect);
	}

	// draw cached end icon again
	fOffView->SetDrawingMode(B_OP_COPY);
	fOffView->FillRect(fOffView->Bounds());
	fOffView->SetDrawingMode(B_OP_ALPHA);
	fOffView->DrawBitmap(end, endRect);
	fOffView->Sync();
	DrawBitmap(fOffBitmap, destRect);

	fOffBitmap->Unlock();
}


void
TIconView::Update(int32 previous, int32 current,
	int32 previousSlot, int32 currentSlot, bool forward)
{
	BList* groupList = fManager->GroupList();
	ASSERT(groupList);

	// animate shrinking previously centered icon
	TTeamGroup* previousGroup = (TTeamGroup*)groupList->ItemAt(previous);
	ASSERT(previousGroup);
	AnimateIcon(previousGroup->LargeIcon(), previousGroup->SmallIcon());

	int32 nslots = abs(previousSlot - currentSlot);
	int32 stepSize = fManager->ScrollStep();

	if (forward && (currentSlot < previousSlot)) {
		// we were at the end of the list and we just moved to the start
		forward = false;
		if (previousSlot - currentSlot > 4)
			stepSize *= 2;
	} else if (!forward && (currentSlot > previousSlot)) {
		// we're are moving backwards and we just hit start of list and
		// we wrapped to the end.
		forward = true;
		if (currentSlot - previousSlot > 4)
			stepSize *= 2;
	}

	int32 scrollValue = forward ? stepSize : -stepSize;
	int32 total = 0;

	fAutoScrolling = true;
	while (total < (nslots * fManager->SlotSize())) {
		ScrollBy(scrollValue, 0);
		snooze(1000);
		total += stepSize;
		Window()->UpdateIfNeeded();
	}
	fAutoScrolling = false;

	// animate expanding currently centered icon
	TTeamGroup* currentGroup = (TTeamGroup*)groupList->ItemAt(current);
	ASSERT(currentGroup != NULL);
	AnimateIcon(currentGroup->SmallIcon(), currentGroup->LargeIcon());
}


void
TIconView::CenterOn(int32 index)
{
	BRect rect = FrameOf(index);
	ScrollTo(rect.left - (fManager->CenterSlot() * fManager->SlotSize()), 0);
}


int32
TIconView::ItemAtPoint(BPoint point) const
{
	return IndexAt((int32)(point.x / fManager->SlotSize()) - fManager->CenterSlot());
}


void
TIconView::ScrollTo(BPoint where)
{
	BView::ScrollTo(where);
	fSwitcher->TopView()->DrawIconScrollers(true);
}


int32
TIconView::IndexAt(int32 slot) const
{
	if (slot < 0 || slot >= fManager->GroupList()->CountItems())
		return -1;

	return slot;
}


int32
TIconView::SlotOf(int32 index) const
{
	BRect rect = FrameOf(index);

	return (int32)(rect.left / fManager->SlotSize()) - fManager->CenterSlot();
}


BRect
TIconView::FrameOf(int32 index) const
{
	int32 visible = index + fManager->CenterSlot();
		// first few slots in view are empty

	return BRect(visible * fManager->SlotSize(), 0,
		(visible + 1) * fManager->SlotSize() - 1, fManager->SlotSize() - 1);
}


void
TIconView::DrawTeams(BRect update)
{
	float tint = B_NO_TINT;
	rgb_color panelColor = ui_color(B_PANEL_BACKGROUND_COLOR);

	if (panelColor.IsDark())
		tint = 0.85;
	else
		tint = B_DARKEN_1_TINT;

	SetHighUIColor(B_PANEL_BACKGROUND_COLOR, tint);
	SetLowUIColor(ViewUIColor(), tint);

	FillRect(update);
	int32 mainIndex = fManager->CurrentIndex();
	BList* groupList = fManager->GroupList();
	int32 teamCount = groupList->CountItems();

	BRect rect(fManager->CenterSlot() * fManager->SlotSize(), 0,
		(fManager->CenterSlot() + 1) * fManager->SlotSize() - 1,
		fManager->SlotSize() - 1);

	for (int32 i = 0; i < teamCount; i++) {
		TTeamGroup* group = (TTeamGroup*)groupList->ItemAt(i);
		if (rect.Intersects(update) && group != NULL) {
			SetDrawingMode(B_OP_ALPHA);
			SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

			group->Draw(this, rect, !fAutoScrolling && (i == mainIndex));

			SetDrawingMode(B_OP_COPY);
		}
		rect.OffsetBy(fManager->SlotSize(), 0);
	}
}


void
TIconView::Draw(BRect update)
{
	DrawTeams(update);
}


void
TIconView::MouseDown(BPoint where)
{
	int32 index = ItemAtPoint(where);
	if (index >= 0) {
		int32 previousIndex = fManager->CurrentIndex();
		int32 previousSlot = fManager->CurrentSlot();
		int32 currentSlot = SlotOf(index);
		fManager->SwitchToApp(previousIndex, index, (currentSlot
			> previousSlot));
	}
}


void
TIconView::Pulse()
{
	uint32 modifiersKeys = modifiers();
	if (fSwitcher->HairTrigger() && (modifiersKeys & B_CONTROL_KEY) == 0) {
		fManager->Stop(true, modifiersKeys);
		return;
	}

	if (!fSwitcher->HairTrigger()) {
		uint32 buttons;
		BPoint point;
		GetMouse(&point, &buttons);
		if (buttons != 0) {
			point = ConvertToScreen(point);
			if (!Window()->Frame().Contains(point))
				fManager->Stop(false, 0);
		}
	}
}


void
TIconView::Showing()
{
}


void
TIconView::Hiding()
{
	ScrollTo(B_ORIGIN);
}


//	#pragma mark - TWindowView


TWindowView::TWindowView(BRect rect, TSwitchManager* manager,
		TSwitcherWindow* window)
	: BView(rect, "wlist_view", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED),
	fCurrentToken(-1),
	fItemHeight(-1),
	fSwitcher(window),
	fManager(manager)
{
	SetFont(be_plain_font);
}


void
TWindowView::AttachedToWindow()
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
}


void
TWindowView::ScrollTo(BPoint where)
{
	BView::ScrollTo(where);
	fSwitcher->TopView()->DrawWindowScrollers(true);
}


BRect
TWindowView::FrameOf(int32 index) const
{
	return BRect(0, index * fItemHeight, 100, ((index + 1) * fItemHeight) - 1);
}


void
TWindowView::GetPreferredSize(float* _width, float* _height)
{
	font_height	fh;
	be_plain_font->GetHeight(&fh);
	fItemHeight = (int32) fh.ascent + fh.descent;

	// top & bottom margin
	float margin = be_control_look->DefaultLabelSpacing();
	fItemHeight = fItemHeight + margin * 2;

	// want fItemHeight to be divisible by kWindowScrollSteps.
	fItemHeight = ((((int)fItemHeight) + kWindowScrollSteps)
		/ kWindowScrollSteps) * kWindowScrollSteps;

	*_height = fItemHeight;

	// leave width alone
	*_width = Bounds().Width();
}


void
TWindowView::ShowIndex(int32 newIndex)
{
	// convert index to scroll location
	BPoint point(0, newIndex * fItemHeight);
	BRect bounds = Bounds();

	int32 groupIndex = fManager->CurrentIndex();
	TTeamGroup* teamGroup
		= (TTeamGroup*)fManager->GroupList()->ItemAt(groupIndex);
	if (teamGroup == NULL)
		return;

	window_info* windowInfo = fManager->WindowInfo(groupIndex, newIndex);
	if (windowInfo == NULL)
		return;

	fCurrentToken = windowInfo->server_token;
	free(windowInfo);

	if (bounds.top == point.y)
		return;

	int32 oldIndex = (int32) (bounds.top / fItemHeight);

	int32 stepSize = (int32) (fItemHeight / kWindowScrollSteps);
	int32 scrollValue = (newIndex > oldIndex) ? stepSize : -stepSize;
	int32 total = 0;
	int32 nslots = abs(newIndex - oldIndex);

	while (total < (nslots * (int32)fItemHeight)) {
		ScrollBy(0, scrollValue);
		snooze(10000);
		total += stepSize;
		Window()->UpdateIfNeeded();
	}
}


void
TWindowView::Draw(BRect update)
{
	int32 groupIndex = fManager->CurrentIndex();
	TTeamGroup* teamGroup
		= (TTeamGroup*)fManager->GroupList()->ItemAt(groupIndex);

	if (teamGroup == NULL)
		return;

	BRect bounds = Bounds();
	int32 windowIndex = (int32) (bounds.top / fItemHeight);
	BRect windowRect = bounds;

	windowRect.top = windowIndex * fItemHeight;
	windowRect.bottom = (windowIndex + 1) * fItemHeight - 1;

	for (int32 i = 0; i < 3; i++) {
		if (!update.Intersects(windowRect)) {
			windowIndex++;
			windowRect.OffsetBy(0, fItemHeight);
			continue;
		}

		// is window in current workspace?

		bool local = true;
		bool minimized = false;
		BString title;

		client_window_info* windowInfo
			= fManager->WindowInfo(groupIndex, windowIndex);
		if (windowInfo != NULL) {
			if (SmartStrcmp(windowInfo->name, teamGroup->Name()) != 0)
				title << teamGroup->Name() << ": " << windowInfo->name;
			else
				title = teamGroup->Name();

			int32 currentWorkspace = current_workspace();
			if ((windowInfo->workspaces & (1 << currentWorkspace)) == 0)
				local = false;

			minimized = windowInfo->is_mini;
			free(windowInfo);
		} else
			title = teamGroup->Name();

		if (!title.Length())
			return;

		float iconWidth = 0;

		// get the (cached) window icon bitmap
		TBarApp* app = static_cast<TBarApp*>(be_app);
		const BBitmap* bitmap = app->FetchWindowIcon(local, minimized);
		if (bitmap != NULL)
			iconWidth = bitmap->Bounds().Width();

		float spacing = be_control_look->DefaultLabelSpacing();
		float stringWidth = StringWidth(title.String());
		float maxWidth = bounds.Width();
		if (bitmap != NULL)
			maxWidth -= (iconWidth + spacing);

		if (stringWidth > maxWidth) {
			// window title is too long, need to truncate
			TruncateString(&title, B_TRUNCATE_MIDDLE, maxWidth);
			stringWidth = maxWidth;
		}

		BPoint point((bounds.Width() - stringWidth) / 2, windowRect.bottom);
		if (bitmap != NULL) {
			point.x = (bounds.Width()
				- (stringWidth + iconWidth + spacing)) / 2;
		}

		BPoint p(point.x, (windowRect.top + windowRect.bottom) / 2);
		SetDrawingMode(B_OP_OVER);

		// center bitmap horizontally and move text past icon
		if (bitmap != NULL) {
			p.y -= (bitmap->Bounds().bottom - bitmap->Bounds().top) / 2;
			DrawBitmap(bitmap, p);

			point.x += bitmap->Bounds().Width() + spacing;
		}

		// center text vertically
		font_height fontHeight;
		GetFontHeight(&fontHeight);
		float textHeight = fontHeight.ascent + fontHeight.descent;
		point.y -= (textHeight / 2) + (spacing / 2);
		if (bitmap != NULL) {
			// center in middle of window icon
			point.y += ((textHeight - bitmap->Bounds().Height()) / 2);
		}

		MovePenTo(point);

		SetHighUIColor(B_PANEL_TEXT_COLOR);
		DrawString(title.String());
		SetDrawingMode(B_OP_COPY);

		windowIndex++;
		windowRect.OffsetBy(0, fItemHeight);
	}
}


void
TWindowView::UpdateGroup(int32, int32 windowIndex)
{
	ScrollTo(0, windowIndex * fItemHeight);
	Invalidate(Bounds());
}


void
TWindowView::Pulse()
{
	// If selected window went away then reset to first window
	window_info	*windowInfo = get_window_info(fCurrentToken);
	if (windowInfo == NULL) {
		Invalidate();
		ShowIndex(0);
	} else
		free(windowInfo);
}