gui/main_window/SchedulingPage.cpp

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "main_window/SchedulingPage.h"

#include <stdio.h>

#include <algorithm>
#include <new>

#include <LayoutBuilder.h>
#include <LayoutUtils.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <ScrollView.h>
#include <SplitView.h>
#include <ToolTip.h>

#include <DebugEventStream.h>

#include <thread_defs.h>

#include "Array.h"

#include "chart/NanotimeChartAxisLegendSource.h"
#include "chart/LegendChartAxis.h"
#include "chart/StringChartLegend.h"
#include "HeaderView.h"
#include "Model.h"
#include "util/TimeUtils.h"


static const float kThreadNameMargin = 3.0f;
static const float kViewSeparationMargin = 1.0f;


enum {
	MSG_SCHEDULING_FILTER_HIDE_SELECTED		= 'schs',
	MSG_SCHEDULING_FILTER_HIDE_UNSELECTED	= 'schu',
	MSG_SCHEDULING_FILTER_SHOW_ALL			= 'scsa'
};


enum {
	IO_SCHEDULING_STATE_IDLE,
	IO_SCHEDULING_STATE_PENDING_REQUEST,
	IO_SCHEDULING_STATE_PENDING_OPERATION
};


struct MainWindow::SchedulingPage::SchedulingEvent {
	nanotime_t						time;
	Model::ThreadWaitObjectGroup*	waitObject;
	ThreadState						state;

	SchedulingEvent(nanotime_t time, ThreadState state,
		Model::ThreadWaitObjectGroup* waitObject)
		:
		time(time),
		waitObject(waitObject),
		state(state)
	{
	}
};


struct MainWindow::SchedulingPage::IOSchedulingEvent {
	nanotime_t	time;
	uint32		state;

	IOSchedulingEvent(nanotime_t time, uint32 state)
		:
		time(time),
		state(state)
	{
	}
};


class MainWindow::SchedulingPage::SchedulingData {
public:
	SchedulingData()
		:
		fModel(NULL),
		fDataArrays(NULL),
		fIODataArrays(NULL),
		fRecordingEnabled(false)
	{
	}

	status_t InitCheck() const
	{
		return fDataArrays != NULL && fIODataArrays != NULL
			? B_OK : B_NO_MEMORY;
	}

	void SetModel(Model* model)
	{
		delete[] fDataArrays;
		delete[] fIODataArrays;

		fModel = model;
		fDataArrays = NULL;
		fIODataArrays = NULL;

		if (fModel != NULL) {
			int32 threadCount = fModel->CountThreads();
			fDataArrays = new(std::nothrow) DataArray[threadCount];
			fIODataArrays = new(std::nothrow) IODataArray[threadCount];
		}
	}

	void SetRecordingEnabled(bool enabled)
	{
		fRecordingEnabled = enabled;
	}

	void Clear()
	{
		int32 count = fModel->CountThreads();

		if (fDataArrays != NULL) {
			for (int32 i = 0; i < count; i++)
				fDataArrays[i].Clear();
		}

		if (fIODataArrays != NULL) {
			for (int32 i = 0; i < count; i++)
				fIODataArrays[i].Clear();
		}
	}

	const Array<SchedulingEvent>& EventsForThread(int32 index)
	{
		return fDataArrays[index];
	}

	const Array<IOSchedulingEvent>& IOEventsForThread(int32 index)
	{
		return fIODataArrays[index];
	}

	void AddState(Model::Thread* thread, nanotime_t time, ThreadState state,
		Model::ThreadWaitObjectGroup* waitObject)
	{
		DataArray& array = fDataArrays[thread->Index()];
		if (!array.IsEmpty()) {
			SchedulingEvent& lastEvent = array[array.Size() - 1];
			if (fRecordingEnabled) {
				if (lastEvent.state == state
					&& lastEvent.waitObject == waitObject) {
					return;
				}
			} else {
				// recording not enabled yet -- overwrite the last event
				lastEvent = SchedulingEvent(time, state, waitObject);
				return;
			}
		}

		SchedulingEvent event(time, state, waitObject);
		array.Add(event);
	}

	void AddIOState(Model::Thread* thread, nanotime_t time, uint32 state)
	{
		IODataArray& array = fIODataArrays[thread->Index()];
		array.Add(IOSchedulingEvent(time, state));
	}

	void AddRun(Model::Thread* thread, nanotime_t time)
	{
		AddState(thread, time, RUNNING, NULL);
	}

	void AddLatency(Model::Thread* thread, nanotime_t time)
	{
		AddState(thread, time, READY, NULL);
	}

	void AddPreemption(Model::Thread* thread, nanotime_t time)
	{
		AddState(thread, time, PREEMPTED, NULL);
	}

	void AddWait(Model::Thread* thread, nanotime_t time,
		Model::ThreadWaitObjectGroup* waitObject)
	{
		AddState(thread, time, WAITING, waitObject);
	}

	void AddUnspecifiedWait(Model::Thread* thread, nanotime_t time)
	{
		AddState(thread, time, WAITING, NULL);
	}

private:
	typedef Array<SchedulingEvent> DataArray;
	typedef Array<IOSchedulingEvent> IODataArray;

private:
	Model*			fModel;
	DataArray*		fDataArrays;
	IODataArray*	fIODataArrays;
	bool			fRecordingEnabled;
};


struct MainWindow::SchedulingPage::TimeRange : BReferenceable {
	nanotime_t	startTime;
	nanotime_t	endTime;

	TimeRange(nanotime_t startTime, nanotime_t endTime)
		:
		startTime(startTime),
		endTime(endTime)
	{
	}
};


class MainWindow::SchedulingPage::TimelineHeaderRenderer
	: public HeaderRenderer {
public:
	TimelineHeaderRenderer()
		:
		fAxis(new NanotimeChartAxisLegendSource, new StringChartLegendRenderer)
	{
		fAxis.SetLocation(CHART_AXIS_TOP);
	}

	virtual float HeaderHeight(BView* view, const Header* header)
	{
		_SetupAxis(view, header);
		return fAxis.PreferredSize(view, view->Frame().Size()).height;
	}

	virtual float PreferredHeaderWidth(BView* view, const Header* header)
	{
		_SetupAxis(view, header);
		return fAxis.PreferredSize(view, view->Frame().Size()).width;
	}

	virtual void DrawHeader(BView* view, BRect frame, BRect updateRect,
		const Header* header, uint32 flags)
	{
		_SetupAxis(view, header);
		fAxis.SetFrame(frame);
		DrawHeaderBackground(view, frame, updateRect, flags);
		fAxis.Render(view, updateRect);
	}

private:
	void _SetupAxis(BView* view, const Header* header)
	{
		BVariant value;
		if (header->GetValue(value)) {
			TimeRange* timeRange = dynamic_cast<TimeRange*>(
				value.ToReferenceable());
			if (timeRange != NULL) {
				ChartDataRange range = ChartDataRange(timeRange->startTime,
					timeRange->endTime);
				if (range != fRange) {
					fAxis.SetRange(range);
					fRange = range;
				}
			}
		}
	}

private:
	LegendChartAxis		fAxis;
	ChartDataRange		fRange;
};


class MainWindow::SchedulingPage::BaseView : public BView {
public:
	BaseView(const char* name, FontInfo& fontInfo,
		ListSelectionModel* filterModel, uint32 flags = 0)
		:
		BView(name, flags),
		fModel(NULL),
		fFilterModel(filterModel),
		fFontInfo(fontInfo)
	{
	}

	virtual void SetModel(Model* model)
	{
		fModel = model;

		InvalidateLayout();
	}

protected:
	int32 CountLines() const
	{
		return fFilterModel->CountSelectedItems();
	}

	float TotalHeight() const
	{
		return fFontInfo.lineHeight * CountLines();
	}

	int32 LineAt(BPoint point) const
	{
		int32 line = (int32)point.y / (int32)fFontInfo.lineHeight;
		return line < CountLines() ? line : -1;
	}

	void GetLineRange(BRect rect, int32& minLine, int32& maxLine) const
	{
		int32 lineHeight = (int32)fFontInfo.lineHeight;
		minLine = (int32)rect.top / lineHeight;
		maxLine = ((int32)ceilf(rect.bottom) + lineHeight - 1) / lineHeight;
		minLine = std::max(minLine, (int32)0);
		maxLine = std::min(maxLine, CountLines() - 1);
	}

	BRect LineRect(uint32 line) const
	{
		float y = (float)line * fFontInfo.lineHeight;
		return BRect(0, y, Bounds().right, y + fFontInfo.lineHeight - 1);
	}

protected:
	Model*				fModel;
	ListSelectionModel*	fFilterModel;
	FontInfo&			fFontInfo;
};


class MainWindow::SchedulingPage::LineBaseView : public BaseView,
	protected ListSelectionModel::Listener {
public:
	LineBaseView(const char* name, FontInfo& fontInfo,
		ListSelectionModel* filterModel, ListSelectionModel* selectionModel)
		:
		BaseView(name, fontInfo, filterModel, B_WILL_DRAW),
		fSelectionModel(selectionModel),
		fTextColor(ui_color(B_DOCUMENT_TEXT_COLOR)),
		fSelectedTextColor(fTextColor),
		fBackgroundColor(ui_color(B_DOCUMENT_BACKGROUND_COLOR)),
		fSelectedBackgroundColor(tint_color(fBackgroundColor, B_DARKEN_2_TINT))
	{
		fFilterModel->AddListener(this);
		fSelectionModel->AddListener(this);
	}

	void RemoveListeners()
	{
		fSelectionModel->RemoveListener(this);
		fFilterModel->RemoveListener(this);
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case MSG_SCHEDULING_FILTER_HIDE_SELECTED:
			{
				int32 filteredCount = fFilterModel->CountSelectedItems();
				int32 selectedCount = fSelectionModel->CountSelectedItems();
				if (selectedCount == 0 || selectedCount == filteredCount)
					break;

				// Set the filter model to the unselected items.
				ListSelectionModel tempModel;
				for (int32 i = 0; i < filteredCount; i++) {
					if (!fSelectionModel->IsItemSelected(i)) {
						tempModel.SelectItem(fFilterModel->SelectedItemAt(i),
							true);
					}
				}

				fSelectionModel->Clear();
				*fFilterModel = tempModel;
				Invalidate();
				break;
			}

			case MSG_SCHEDULING_FILTER_HIDE_UNSELECTED:
			{
				int32 filteredCount = fFilterModel->CountSelectedItems();
				int32 selectedCount = fSelectionModel->CountSelectedItems();
				if (selectedCount == 0 || selectedCount == filteredCount)
					break;

				// Set the filter model to the selected items.
				// There might already be a filter applied, so we have to
				// build the new filter model manually.
				ListSelectionModel tempModel;
				for (int32 i = 0; i < selectedCount; i++) {
					int32 index = fFilterModel->SelectedItemAt(
						fSelectionModel->SelectedItemAt(i));
					if (index >= 0)
						tempModel.SelectItem(index, true);
				}

				fSelectionModel->Clear();
				*fFilterModel = tempModel;
				Invalidate();
				break;
			}

			case MSG_SCHEDULING_FILTER_SHOW_ALL:
			{
				int32 threadCount = fModel->CountThreads();
				if (fFilterModel->CountSelectedItems() == threadCount)
					break;

				// unset the filter
				ListSelectionModel tempModel = *fFilterModel;
				fSelectionModel->Clear();
				fFilterModel->SelectItems(0, threadCount, false);
				*fSelectionModel = tempModel;
				Invalidate();
				break;
			}

			default:
				BaseView::MessageReceived(message);
				break;
		}
	}

	virtual void MouseDown(BPoint where)
	{
		// get buttons and modifiers
		BMessage* message = Looper()->CurrentMessage();
		if (message == NULL)
			return;

		int32 buttons;
		if (message->FindInt32("buttons", &buttons) != B_OK)
			return;

		int32 modifiers;
		if (message->FindInt32("modifiers", &modifiers) != B_OK)
			modifiers = 0;

		// update selection
		int32 line = LineAt(where);
		if (line >= 0) {
			if ((modifiers & B_SHIFT_KEY) != 0) {
				int32 selectedLines = fSelectionModel->CountSelectedItems();
				if (selectedLines > 0) {
					int32 firstLine = fSelectionModel->SelectedItemAt(0);
					int32 lastLine = fSelectionModel->SelectedItemAt(
						selectedLines - 1);
					firstLine = std::min(firstLine, line);
					lastLine = std::max(lastLine, line);
					fSelectionModel->SelectItems(firstLine,
						lastLine - firstLine + 1, false);
				} else
					fSelectionModel->SelectItem(line, true);
			} else {
				if (fSelectionModel->IsItemSelected(line)) {
					if ((modifiers & B_COMMAND_KEY) != 0)
						fSelectionModel->DeselectItem(line);
				} else {
					fSelectionModel->SelectItem(line,
						(modifiers & B_COMMAND_KEY) != 0);
				}
			}
		} else
			fSelectionModel->Clear();

		// on right mouse button open context menu
		if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0 && fModel != NULL) {
			BPopUpMenu* contextMenu = new BPopUpMenu("scheduling context menu",
				false, false);

			int32 filteredCount = fFilterModel->CountSelectedItems();
			int32 selectedCount = fSelectionModel->CountSelectedItems();

			BMenuItem* item = new BMenuItem("Hide selected threads",
				new BMessage(MSG_SCHEDULING_FILTER_HIDE_SELECTED));
			contextMenu->AddItem(item);
			item->SetTarget(this);
			if (selectedCount == 0 || selectedCount == filteredCount)
				item->SetEnabled(false);

			item = new BMenuItem("Hide unselected threads",
				new BMessage(MSG_SCHEDULING_FILTER_HIDE_UNSELECTED));
			contextMenu->AddItem(item);
			item->SetTarget(this);
			if (selectedCount == 0 || selectedCount == filteredCount)
				item->SetEnabled(false);

			item = new BMenuItem("Show all threads",
				new BMessage(MSG_SCHEDULING_FILTER_SHOW_ALL));
			contextMenu->AddItem(item);
			item->SetTarget(this);
			if (filteredCount == fModel->CountThreads())
				item->SetEnabled(false);

			BPoint screenWhere = ConvertToScreen(where);
			BRect mouseRect(screenWhere, screenWhere);
			mouseRect.InsetBy(-4.0, -4.0);
			contextMenu->Go(screenWhere, true, false, mouseRect, true);
		}
	}

	virtual void ItemsSelected(ListSelectionModel* model, int32 index,
		int32 count)
	{
		if (model == fFilterModel)
			Invalidate();
		else
			InvalidateLines(index, count);
	}

	virtual void ItemsDeselected(ListSelectionModel* model, int32 index,
		int32 count)
	{
		if (model == fFilterModel)
			Invalidate();
		else
			InvalidateLines(index, count);
	}

	void InvalidateLines(int32 index, int32 count)
	{
		float top = (float)index * fFontInfo.lineHeight;
		float bottom = (float)(index + count) * fFontInfo.lineHeight - 1;
		BRect bounds(Bounds());
		Invalidate(BRect(bounds.left, top, bounds.right, bottom));
	}

protected:
	ListSelectionModel*		fSelectionModel;
	rgb_color				fTextColor;
	rgb_color				fSelectedTextColor;
	rgb_color				fBackgroundColor;
	rgb_color				fSelectedBackgroundColor;
};


class MainWindow::SchedulingPage::ThreadsView : public LineBaseView {
public:
	ThreadsView(FontInfo& fontInfo, ListSelectionModel* filterModel,
		ListSelectionModel* selectionModel)
		:
		LineBaseView("threads", fontInfo, filterModel, selectionModel)
	{
		SetViewColor(B_TRANSPARENT_32_BIT);
	}

	~ThreadsView()
	{
	}

	virtual void Draw(BRect updateRect)
	{
		if (fModel == NULL)
			return;

		// get the lines intersecting with the update rect
		int32 minLine, maxLine;
		GetLineRange(updateRect, minLine, maxLine);

		for (int32 i = minLine; i <= maxLine; i++) {
			// draw the line background
			BRect lineRect = LineRect(i);
			if (fSelectionModel->IsItemSelected(i)) {
				SetLowColor(fSelectedBackgroundColor);
				SetHighColor(fTextColor);
			} else {
				SetLowColor(fBackgroundColor);
				SetHighColor(fSelectedTextColor);
			}
			FillRect(lineRect, B_SOLID_LOW);

			Model::Thread* thread = fModel->ThreadAt(
				fFilterModel->SelectedItemAt(i));
			if (thread == NULL)
				continue;

			// compose name string
			BString name = thread->Name();
			name << " (" << thread->ID() << ")";

			// draw the string
			float y = lineRect.bottom - fFontInfo.fontHeight.descent + 1;
			DrawString(name, BPoint(kThreadNameMargin, y));
		}

		BRect bounds(Bounds());
		BRect lowerRect(0, (float)CountLines() * fFontInfo.lineHeight,
			bounds.Width(), bounds.Height());
		if (lowerRect.Intersects(updateRect)) {
			SetHighColor(fBackgroundColor);
			FillRect(lowerRect);
		}
	}

	virtual BSize MinSize()
	{
		return BSize(100, TotalHeight());
	}

	virtual BSize PreferredSize()
	{
		return BSize(250, TotalHeight());
	}

	virtual BSize MaxSize()
	{
		return BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
	}
};


class MainWindow::SchedulingPage::SchedulingView : public LineBaseView {
public:
	struct Listener {
		virtual ~Listener()
		{
		}

		virtual void DataWidthChanged() = 0;
		virtual void DataRangeChanged() = 0;
	};

private:
	enum {
		COLOR_RUNNING = 0,
		COLOR_PREEMPTED,
		COLOR_READY,
		COLOR_IO_REQUEST,
		COLOR_IO_OPERATION,
		ACTIVITY_COLOR_COUNT
	};

public:
	SchedulingView(FontInfo& fontInfo, ListSelectionModel* filterModel,
		ListSelectionModel* selectionModel)
		:
		LineBaseView("scheduling", fontInfo, filterModel, selectionModel),
		fStartTime(0),
		fEndTime(0),
		fNSecsPerPixel(1000000),
		fLastMousePos(-1, -1),
		fListener(NULL)
	{
		fActivityColors[COLOR_RUNNING].set_to(0, 255, 0);
		fActivityColors[COLOR_PREEMPTED].set_to(255, 127, 0);
		fActivityColors[COLOR_READY].set_to(255, 0, 0);
		fActivityColors[COLOR_IO_REQUEST].set_to(127, 127, 255);
		fActivityColors[COLOR_IO_OPERATION].set_to(0, 0, 200);

		fActivitySelectedColors[COLOR_RUNNING] = tint_color(
			fActivityColors[COLOR_RUNNING], B_DARKEN_2_TINT);
		fActivitySelectedColors[COLOR_PREEMPTED] = tint_color(
			fActivityColors[COLOR_PREEMPTED], B_DARKEN_2_TINT);
		fActivitySelectedColors[COLOR_READY] = tint_color(
			fActivityColors[COLOR_READY], B_DARKEN_2_TINT);
		fActivitySelectedColors[COLOR_IO_REQUEST] = tint_color(
			fActivityColors[COLOR_IO_REQUEST], B_DARKEN_2_TINT);
		fActivitySelectedColors[COLOR_IO_OPERATION] = tint_color(
			fActivityColors[COLOR_IO_OPERATION], B_DARKEN_2_TINT);
	}

	~SchedulingView()
	{
	}

	virtual void SetModel(Model* model)
	{
		LineBaseView::SetModel(model);
		fSchedulingData.SetModel(model);
		fStartTime = 0;
		fEndTime = 0;

		if (fListener != NULL) {
			fListener->DataWidthChanged();
			fListener->DataRangeChanged();
		}

	}

	void SetListener(Listener* listener)
	{
		fListener = listener;
	}

	void UpdateScrollBar()
	{
		float width = Frame().Width();
		float dataWidth = std::max(width, MinSize().width);

		if (BScrollBar* scrollBar = ScrollBar(B_HORIZONTAL)) {
			float range = dataWidth - width;
			if (range > 0) {
				scrollBar->SetRange(0, range);
				scrollBar->SetProportion((width + 1) / (dataWidth + 1));
				scrollBar->SetSteps(fFontInfo.lineHeight, width + 1);
			} else {
				scrollBar->SetRange(0, 0);
				scrollBar->SetProportion(1);
			}
		}
	}

	void GetDataRange(nanotime_t& _startTime, nanotime_t& _endTime)
	{
		_GetEventTimeRange(_startTime, _endTime);
	}

	virtual BSize MinSize()
	{
		nanotime_t timeSpan = fModel != NULL ? fModel->LastEventTime() : 0;
		float width = std::max(float(timeSpan / fNSecsPerPixel), 100.0f);
		return BSize(width, TotalHeight());
	}

	virtual BSize MaxSize()
	{
		return BSize(MinSize().width, B_SIZE_UNLIMITED);
	}

	virtual void ScrollTo(BPoint where)
	{
		LineBaseView::ScrollTo(where);
		fStartTime = 0;
		fEndTime = 0;

		if (fListener != NULL)
			fListener->DataRangeChanged();
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case B_MOUSE_WHEEL_CHANGED:
			{
				// We're only interested in Shift + vertical wheel.
				float deltaY;
				if ((modifiers() & B_SHIFT_KEY) == 0
					|| message->FindFloat("be:wheel_delta_y", &deltaY)
						!= B_OK) {
					break;
				}

				_Zoom(fLastMousePos.x, deltaY);

				return;
			}
		}

		LineBaseView::MessageReceived(message);
	}

	virtual void MouseMoved(BPoint where, uint32 code,
		const BMessage* dragMessage)
	{
		fLastMousePos = where - LeftTop();

//		if (fDraggingStartPos.x < 0)
//			return;
//
//		ScrollBar(B_HORIZONTAL)->SetValue(fDraggingStartScrollValue
//			+ fDraggingStartPos.x - where.x);
	}

	virtual bool GetToolTipAt(BPoint point, BToolTip** _tip)
	{
		Model::Thread* thread;
		nanotime_t time;
		_GetThreadAndTimeAt(point, thread, time);
		if (thread == NULL)
			return false;

		// get the thread's state
		ThreadState threadState = UNKNOWN;
		nanotime_t threadStateTime = time;
		nanotime_t threadStateEndTime = time;
		Model::ThreadWaitObjectGroup* threadWaitObject = NULL;
		{
			const Array<SchedulingEvent>& events
				= fSchedulingData.EventsForThread(thread->Index());
			int32 eventCount = events.Size();

			int32 lower = 0;
			int32 upper = eventCount - 1;
			while (lower < upper) {
				int32 mid = (lower + upper + 1) / 2;
				const SchedulingEvent& event = events[mid];
				if (event.time > time)
					upper = mid - 1;
				else
					lower = mid;
			}

			if (lower >= 0 && lower < eventCount) {
				threadState = events[lower].state;
				threadStateTime = events[lower].time;
				threadWaitObject = events[lower].waitObject;
				if (lower + 1 < eventCount)
					threadStateEndTime = events[lower + 1].time;
				else
					threadStateEndTime = fModel->LastEventTime();
			}
		}

		// get the thread's I/O state
		BObjectList<Model::IORequest> ioRequests;
		_GetIORequests(thread, time, ioRequests);

		// find out which threads are running
		system_profiler_event_header** events = fModel->Events();
		size_t eventIndex = fModel->ClosestEventIndex(time + 1);
			// find the first event after the one we're interested in; we'll
			// skip it in the loop

		int32 cpuCount = fModel->CountCPUs();
		int32 missingThreads = cpuCount;
		Model::Thread* runningThreads[cpuCount];
		memset(runningThreads, 0, sizeof(Model::Thread*) * cpuCount);

		while (missingThreads > 0 && eventIndex > 0) {
			eventIndex--;
			system_profiler_event_header* header = events[eventIndex];
			if (header->event != B_SYSTEM_PROFILER_THREAD_SCHEDULED
				|| runningThreads[header->cpu] != NULL) {
				continue;
			}

			system_profiler_thread_scheduled* event
				= (system_profiler_thread_scheduled*)(header + 1);
			if (Model::Thread* thread = fModel->ThreadByID(event->thread)) {
				runningThreads[header->cpu] = thread;
				missingThreads--;
			}
		}

		// create the tool tip
		BString text;
		text << "Time: " << format_nanotime(time) << "\n";
		text << "Thread: " << thread->Name() << " (" << thread->ID() << ")\n";
		text << "State: " << thread_state_name(threadState);
		if (threadWaitObject != NULL) {
			char objectName[32];
			snprintf(objectName, sizeof(objectName), "%#lx",
				threadWaitObject->Object());
			text << " at " << wait_object_type_name(threadWaitObject->Type())
				<< " \"" << threadWaitObject->Name() << "\" "
				<< objectName << "\n";
		} else
			text << "\n";
		text << "For: " << format_nanotime(time - threadStateTime) << " of "
			<< format_nanotime(threadStateEndTime - threadStateTime);

		if (!ioRequests.IsEmpty()) {
			int32 scheduler = 0;
			for (int32 i = 0; Model::IORequest* request = ioRequests.ItemAt(i);
					i++) {
				if (i == 0 || scheduler != request->Scheduler()) {
					scheduler = request->Scheduler();
					text << "\nI/O channel " << scheduler << ":";
				}
				text << "\n  " << (request->IsWrite() ? "write" : "read")
					<< " request: " << request->BytesTransferred() << "/"
					<< request->Length() << " ";
				if (request->IsFinished()) {
					text << (request->Status() == B_OK ? "ok" : "failed");
					text << ", "
						<< format_nanotime(
							request->FinishedTime() - request->ScheduledTime());
				} else
					text << "unfinished";

				for (size_t k = 0; k < request->operationCount; k++) {
					Model::IOOperation& operation = request->operations[k];
					if (operation.startedEvent->time > fModel->BaseTime() + time
						|| (operation.IsFinished()
							&& operation.FinishedTime()
								<= fModel->BaseTime() + time)) {
						continue;
					}

					text << "\n    " << (operation.IsWrite() ? "write" : "read")
						<< ": " << operation.BytesTransferred() << "/"
						<< operation.Length() << " ";
					if (operation.IsFinished()) {
						text << (request->Status() == B_OK ? "ok" : "failed");
						text << ", "
							<< format_nanotime(operation.FinishedTime()
								- operation.StartedTime());
					} else
						text << "unfinished";
				}
			}
		}

		text << "\n\n";
		text << "Running threads:";
		for (int32 i = 0; i < cpuCount; i++) {
			text << "\n  " << i << ": ";
			if (Model::Thread* thread = runningThreads[i])
				text << thread->Name() << " (" << thread->ID() << ")";
			else
				text << "?";
		}

		*_tip = new(std::nothrow) BTextToolTip(text);
		return *_tip != NULL;
	}

	virtual void Draw(BRect updateRect)
	{
		if (fModel == NULL || fSchedulingData.InitCheck() != B_OK)
			return;

		_UpdateData();

		// draw the events

		// get the lines intersecting with the update rect
		int32 minLine, maxLine;
		GetLineRange(updateRect, minLine, maxLine);

		for (int32 i = minLine; i <= maxLine; i++) {
			// draw the background
			const rgb_color* activityColors;
			if (fSelectionModel->IsItemSelected(i)) {
				activityColors = fActivitySelectedColors;
				SetLowColor(fSelectedBackgroundColor);
			} else {
				activityColors = fActivityColors;
				SetLowColor(fBackgroundColor);
			}
			BRect lineRect = LineRect(i);
			FillRect(lineRect, B_SOLID_LOW);

			Model::Thread* thread = fModel->ThreadAt(
				fFilterModel->SelectedItemAt(i));
			if (thread == NULL)
				continue;

			BRect schedulingLineRect = lineRect;
			schedulingLineRect.bottom -= lineRect.IntegerHeight() / 2;
			BRect ioLineRect = lineRect;
			ioLineRect.top = schedulingLineRect.bottom + 1;

			const Array<SchedulingEvent>& events
				= fSchedulingData.EventsForThread(thread->Index());

			int32 eventCount = events.Size();
//printf("drawing events for thread %ld: %ld events\n", thread->Index(), eventCount);
			for (int32 k = 0; k < eventCount; k++) {
				const SchedulingEvent& event = events[k];
				nanotime_t startTime = std::max(event.time, fStartTime);
				nanotime_t endTime = k + 1 < eventCount
					? std::min(events[k + 1].time, fEndTime) : fEndTime;

				switch (event.state) {
					case RUNNING:
					case STILL_RUNNING:
						SetHighColor(activityColors[COLOR_RUNNING]);
						break;
					case PREEMPTED:
						SetHighColor(activityColors[COLOR_PREEMPTED]);
						break;
					case READY:
						SetHighColor(activityColors[COLOR_READY]);
						break;
					case WAITING:
					case UNKNOWN:
					default:
						continue;
				}

				BRect rect = schedulingLineRect;
				rect.left = startTime / fNSecsPerPixel;
				rect.right = endTime / fNSecsPerPixel - 1;
				FillRect(rect);
			}

			const Array<IOSchedulingEvent>& ioEvents
				= fSchedulingData.IOEventsForThread(thread->Index());
			eventCount = ioEvents.Size();

			for (int32 k = 0; k < eventCount; k++) {
				const IOSchedulingEvent& event = ioEvents[k];
				nanotime_t startTime = std::max(event.time, fStartTime);
				nanotime_t endTime = k + 1 < eventCount
					? std::min(ioEvents[k + 1].time, fEndTime) : fEndTime;

				switch (event.state) {
					case IO_SCHEDULING_STATE_PENDING_REQUEST:
						SetHighColor(activityColors[COLOR_IO_REQUEST]);
						break;
					case IO_SCHEDULING_STATE_PENDING_OPERATION:
						SetHighColor(activityColors[COLOR_IO_OPERATION]);
						break;
					case IO_SCHEDULING_STATE_IDLE:
					default:
						continue;
				}

				BRect rect = ioLineRect;
				rect.left = startTime / fNSecsPerPixel;
				rect.right = endTime / fNSecsPerPixel - 1;
				FillRect(rect);
			}
		}
	}

private:
	// shorthands for the longish structure names
	typedef system_profiler_thread_enqueued_in_run_queue
		thread_enqueued_in_run_queue;
	typedef system_profiler_thread_removed_from_run_queue
		thread_removed_from_run_queue;

private:
	void _UpdateData()
	{
		// get the interesting event time range
		nanotime_t startTime;
		nanotime_t endTime;
		_GetEventTimeRange(startTime, endTime);

		if (startTime == fStartTime && endTime == fEndTime)
			return;
		fStartTime = startTime;
		fEndTime = endTime;

		fSchedulingData.Clear();

//printf("MainWindow::SchedulingPage::SchedulingView::_UpdateData()\n");
//printf("  time range: %lld - %lld\n", startTime, endTime);

		// get a scheduling state close to our start time
		const Model::CompactSchedulingState* compactState
			= fModel->ClosestSchedulingState(startTime);
//printf("  compactState: %p\n", compactState);
		fState.Clear();
		status_t error = fState.Init(compactState);
		if (error != B_OK)
			return;

		// init the event stream
		BDebugEventInputStream input;
		error = input.SetTo((uint8*)fModel->EventData(),
			fModel->EventDataSize(), false);
		if (error == B_OK && compactState != NULL)
			error = input.Seek(compactState->EventOffset());
//printf("  event offset: %lld, input init error: %s\n", compactState != NULL ? compactState->EventOffset() : 0, strerror(error));
		if (error != B_OK)
			return;

		fSchedulingData.SetRecordingEnabled(
			fState.LastEventTime() >= startTime);

		// add the initial thread states to the scheduling data
		if (compactState != NULL) {
			int32 threadStateCount = compactState->CountThreadsStates();
			for (int32 i = 0; i < threadStateCount; i++) {
				const Model::CompactThreadSchedulingState* threadState
					= compactState->ThreadStateAt(i);
				switch (threadState->state) {
					case RUNNING:
					case STILL_RUNNING:
						fSchedulingData.AddRun(threadState->thread,
							threadState->lastTime);
						break;
					case PREEMPTED:
						fSchedulingData.AddPreemption(threadState->thread,
							threadState->lastTime);
						break;
					case READY:
						fSchedulingData.AddLatency(threadState->thread,
							threadState->lastTime);
						break;
					case WAITING:
					{
						Model::ThreadWaitObjectGroup* group = NULL;
						if (threadState->waitObject != NULL) {
							group = fModel->ThreadWaitObjectGroupFor(
								threadState->ID(),
								threadState->waitObject->Type(),
								threadState->waitObject->Object());
						}
						fSchedulingData.AddWait(threadState->thread,
							threadState->lastTime, group);
						break;
					}
					case UNKNOWN:
					default:
						break;
				}
			}
		}

		// process the events
		while (true) {
			// get next event
			uint32 event;
			uint32 cpu;
			const void* buffer;
			off_t offset;
			ssize_t bufferSize = input.ReadNextEvent(&event, &cpu, &buffer,
				&offset);
			if (bufferSize < 0)
{
printf("failed to read event!\n");
				return;
}
			if (buffer == NULL)
				break;

			// process the event
			error = _ProcessEvent(event, cpu, buffer, bufferSize);
			if (error != B_OK)
				return;

			if (fState.LastEventTime() >= startTime)
				fSchedulingData.SetRecordingEnabled(true);
			if (fState.LastEventTime() >= endTime)
				break;
		}

		// process each thread's I/O events
		nanotime_t lastEventTime = fModel->BaseTime() - fModel->LastEventTime();
		int32 threadCount = fModel->CountThreads();
		for (int32 i = 0; i < threadCount; i++) {
			Model::Thread* thread = fModel->ThreadAt(i);
			Model::IORequest** requests = thread->IORequests();
			size_t requestCount = thread->CountIORequests();
			if (requestCount == 0)
				continue;

			// first request
			nanotime_t clusterStart = requests[0]->scheduledEvent->time;
			nanotime_t clusterEnd = requests[0]->finishedEvent != NULL
				? requests[0]->finishedEvent->time : lastEventTime;
			BObjectList<Model::IOOperation> operations;

			// add first request operations
			for (size_t l = 0; l < requests[0]->operationCount; l++)
				operations.AddItem(&requests[0]->operations[l]);

			for (size_t k = 1; k < requestCount; k++) {
				nanotime_t requestStart = requests[k]->scheduledEvent->time;
				nanotime_t requestEnd = requests[k]->finishedEvent != NULL
					? requests[k]->finishedEvent->time : lastEventTime;

				if (requestStart >= endTime)
					break;

				if (requestStart > clusterEnd) {
					if (clusterEnd > startTime) {
						_AddThreadIOData(thread, clusterStart, clusterEnd,
							operations);
					}
					operations.MakeEmpty();
					clusterStart = requestStart;
					clusterEnd = requestEnd;
				} else
					clusterEnd = std::max(clusterEnd, requestEnd);

				// add request operations
				for (size_t l = 0; l < requests[k]->operationCount; l++)
					operations.AddItem(&requests[k]->operations[l]);
			}

			if (clusterEnd > startTime)
				_AddThreadIOData(thread, clusterStart, clusterEnd, operations);
		}
	}

	void _AddThreadIOData(Model::Thread* thread, nanotime_t startTime,
		nanotime_t endTime, BObjectList<Model::IOOperation>& operations)
	{
//printf("  IORequest cluster: %lld - %lld\n", startTime, endTime);
		// start in pending request state
		fSchedulingData.AddIOState(thread, startTime - fModel->BaseTime(),
			IO_SCHEDULING_STATE_PENDING_REQUEST);

		int32 operationCount = operations.CountItems();
		if (operationCount == 0)
			return;

		// sort the operations
		if (operationCount > 1)
			operations.SortItems(Model::IOOperation::CompareByTime);

		nanotime_t lastEventTime = fModel->BaseTime() + fModel->LastEventTime();

		// process the operations
		Model::IOOperation* operation = operations.ItemAt(0);
		nanotime_t clusterStart = operation->startedEvent->time;
		nanotime_t clusterEnd = operation->finishedEvent != NULL
			? operation->finishedEvent->time : lastEventTime;

		for (int32 i = 1; i < operationCount; i++) {
			operation = operations.ItemAt(i);
			nanotime_t operationStart = operation->startedEvent->time;
			nanotime_t operationEnd = operation->finishedEvent != NULL
				? operation->finishedEvent->time : lastEventTime;

			if (operationStart > clusterEnd) {
				fSchedulingData.AddIOState(thread,
					clusterStart - fModel->BaseTime(),
					IO_SCHEDULING_STATE_PENDING_OPERATION);
				fSchedulingData.AddIOState(thread,
					clusterEnd - fModel->BaseTime(),
					IO_SCHEDULING_STATE_PENDING_REQUEST);

				clusterStart = operationStart;
				clusterEnd = operationEnd;
			} else
				clusterEnd = std::max(clusterEnd, operationEnd);
		}

		// add the last cluster
		fSchedulingData.AddIOState(thread, clusterStart - fModel->BaseTime(),
			IO_SCHEDULING_STATE_PENDING_OPERATION);
		fSchedulingData.AddIOState(thread, clusterEnd - fModel->BaseTime(),
			IO_SCHEDULING_STATE_PENDING_REQUEST);

		// after the end of the request cluster, state is idle again
		fSchedulingData.AddIOState(thread, endTime - fModel->BaseTime(),
			IO_SCHEDULING_STATE_IDLE);
	}

	void _GetEventTimeRange(nanotime_t& _startTime, nanotime_t& _endTime)
	{
		if (fModel != NULL) {
			float scrollOffset = _ScrollOffset();
			_startTime = (nanotime_t)scrollOffset * fNSecsPerPixel;
			_endTime = (nanotime_t)(scrollOffset + Bounds().Width() + 1)
				* fNSecsPerPixel;
		} else {
			_startTime = 0;
			_endTime = 1;
		}
	}

	void _GetThreadAndTimeAt(BPoint point, Model::Thread*& _thread,
		nanotime_t& _time)
	{
		_thread = fModel->ThreadAt(
			fFilterModel->SelectedItemAt(LineAt(point)));
		_time = (nanotime_t)point.x * fNSecsPerPixel;
	}

	void _GetIORequests(Model::Thread* thread, nanotime_t time,
		BObjectList<Model::IORequest>& ioRequests)
	{
		// find the time in the event data
		const Array<IOSchedulingEvent>& events
			= fSchedulingData.IOEventsForThread(thread->Index());
		int32 eventCount = events.Size();

		int32 lower = 0;
		int32 upper = eventCount - 1;
		while (lower < upper) {
			int32 mid = (lower + upper + 1) / 2;
			const IOSchedulingEvent& event = events[mid];
			if (event.time > time)
				upper = mid - 1;
			else
				lower = mid;
		}

		if (lower < 0 || lower >= eventCount)
			return;

		if (events[lower].state == IO_SCHEDULING_STATE_IDLE)
			return;

		// find the beginning and end of the I/O request cluster
		while (lower > 0) {
			if (events[lower - 1].state == IO_SCHEDULING_STATE_IDLE)
				break;
			lower--;
		}

		while (upper + 1 < eventCount) {
			upper++;
			if (events[upper].state == IO_SCHEDULING_STATE_IDLE)
				break;
		}

		nanotime_t startTime = events[lower].time;
		nanotime_t endTime = events[upper].state == IO_SCHEDULING_STATE_IDLE
			? events[upper].time : fEndTime;

		// convert to absolute time -- as used by the I/O requests
		startTime += fModel->BaseTime();
		endTime += fModel->BaseTime();
		time += fModel->BaseTime();

		// collect the requests in the range
		Model::IORequest** requests = thread->IORequests();
		size_t requestCount = thread->CountIORequests();
		size_t index = thread->ClosestRequestStartIndex(startTime);
		for (; index < requestCount; index++) {
			Model::IORequest* request = requests[index];

			if (request->ScheduledTime() >= endTime)
				break;

			if (request->ScheduledTime() > time
				|| (request->finishedEvent != NULL
					&& request->finishedEvent->time <= time)) {
				continue;
			}

			ioRequests.AddItem(request);
		}

		if (ioRequests.CountItems() > 1)
			ioRequests.SortItems(Model::IORequest::CompareSchedulerTime);
	}

	float _ScrollOffset() const
	{
		if (BScrollBar* scrollBar = ScrollBar(B_HORIZONTAL))
			return scrollBar->Value();
		return 0;
	}

	void _Zoom(float x, float steps)
	{
		if (steps == 0 || fModel == NULL)
			return;

		// compute the domain point where to zoom in
		float scrollOffset = _ScrollOffset();
		double timeForX = (scrollOffset + x) * fNSecsPerPixel;

		uint32 factor = 4;
		if (steps < 0) {
			steps = -steps;
			factor = 1;
		}

		uint32 oldNsecPerPixel = fNSecsPerPixel;
		for (; steps > 0; steps--)
			fNSecsPerPixel = fNSecsPerPixel * factor / 2;

		if (fNSecsPerPixel < 1)
			fNSecsPerPixel = 1;
		else if (fNSecsPerPixel > 1000000)
			fNSecsPerPixel = 1000000;

		if (fNSecsPerPixel == oldNsecPerPixel)
			return;

		Invalidate();

		UpdateScrollBar();
		if (BScrollBar* scrollBar = ScrollBar(B_HORIZONTAL))
			scrollBar->SetValue(timeForX / fNSecsPerPixel - x);

		if (fListener != NULL) {
			fListener->DataWidthChanged();
			fListener->DataRangeChanged();
		}
	}

	inline void _UpdateLastEventTime(nanotime_t time)
	{
		fState.SetLastEventTime(time - fModel->BaseTime());
	}

	status_t _ProcessEvent(uint32 event, uint32 cpu, const void* buffer,
		size_t size)
	{
		switch (event) {
			case B_SYSTEM_PROFILER_THREAD_ADDED:
				_HandleThreadAdded((system_profiler_thread_added*)buffer);
				break;

			case B_SYSTEM_PROFILER_THREAD_REMOVED:
				_HandleThreadRemoved((system_profiler_thread_removed*)buffer);
				break;

			case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
				_HandleThreadScheduled(
					(system_profiler_thread_scheduled*)buffer);
				break;

			case B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE:
				_HandleThreadEnqueuedInRunQueue(
					(thread_enqueued_in_run_queue*)buffer);
				break;

			case B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE:
				_HandleThreadRemovedFromRunQueue(
					(thread_removed_from_run_queue*)buffer);
				break;

			default:
				break;
		}

		return B_OK;
	}

	void _HandleThreadAdded(system_profiler_thread_added* event)
	{
//printf("  thread added: %ld\n", event->thread);
		// do we know the thread already?
		Model::ThreadSchedulingState* info = fState.LookupThread(event->thread);
		if (info != NULL) {
			// TODO: ?
			return;
		}

		Model::Thread* thread = fModel->ThreadByID(event->thread);
		if (thread == NULL)
			return;

		// create and add a ThreadSchedulingState
		info = new(std::nothrow) Model::ThreadSchedulingState(thread);
		if (info == NULL)
			return;

		fState.InsertThread(info);
	}

	void _HandleThreadRemoved(system_profiler_thread_removed* event)
	{
//printf("  thread removed: %ld\n", event->thread);
//		Model::ThreadSchedulingState* thread = fState.LookupThread(
//			event->thread);
//		if (thread != NULL) {
//			fState.RemoveThread(thread);
//			delete thread;
//// TODO: The thread will be unscheduled in a moment and cause a warning! So
//// maybe keep it around in a separate hash table a bit longer?
//		}
	}

	void _HandleThreadScheduled(system_profiler_thread_scheduled* event)
	{
		_UpdateLastEventTime(event->time);

		Model::ThreadSchedulingState* thread = fState.LookupThread(
			event->thread);
		if (thread == NULL) {
			printf("Schedule event for unknown thread: %" B_PRId32 "\n",
				event->thread);
			return;
		}

		thread->lastTime = fState.LastEventTime();
		thread->state = RUNNING;
		fSchedulingData.AddRun(thread->thread, fState.LastEventTime());

		// unscheduled thread

		if (event->thread == event->previous_thread)
			return;

		thread = fState.LookupThread(event->previous_thread);
		if (thread == NULL) {
			printf("Schedule event for unknown previous thread: %" B_PRId32
				"\n", event->previous_thread);
			return;
		}

		if (thread->state == STILL_RUNNING) {
			// thread preempted
			fSchedulingData.AddPreemption(thread->thread,
				fState.LastEventTime());

			thread->lastTime = fState.LastEventTime();
			thread->state = PREEMPTED;
		} else if (thread->state == RUNNING) {
			// thread starts waiting (it hadn't been added to the run
			// queue before being unscheduled)
			if (event->previous_thread_state == B_THREAD_WAITING) {
				addr_t waitObject = event->previous_thread_wait_object;
				switch (event->previous_thread_wait_object_type) {
					case THREAD_BLOCK_TYPE_SNOOZE:
					case THREAD_BLOCK_TYPE_SIGNAL:
						waitObject = 0;
						break;
					case THREAD_BLOCK_TYPE_SEMAPHORE:
					case THREAD_BLOCK_TYPE_CONDITION_VARIABLE:
					case THREAD_BLOCK_TYPE_MUTEX:
					case THREAD_BLOCK_TYPE_RW_LOCK:
					case THREAD_BLOCK_TYPE_OTHER:
					case THREAD_BLOCK_TYPE_OTHER_OBJECT:
					default:
						break;
				}

				fSchedulingData.AddWait(thread->thread, fState.LastEventTime(),
					fModel->ThreadWaitObjectGroupFor(thread->ID(),
						event->previous_thread_wait_object_type, waitObject));
			} else {
				fSchedulingData.AddUnspecifiedWait(thread->thread,
					fState.LastEventTime());
			}

			thread->lastTime = fState.LastEventTime();
			thread->state = WAITING;
		} else if (thread->state == UNKNOWN) {
			uint32 threadState = event->previous_thread_state;
			if (threadState == B_THREAD_WAITING
				|| threadState == B_THREAD_SUSPENDED) {
				fSchedulingData.AddWait(thread->thread, fState.LastEventTime(),
					NULL);
				thread->lastTime = fState.LastEventTime();
				thread->state = WAITING;
			} else if (threadState == B_THREAD_READY) {
				thread->lastTime = fState.LastEventTime();
				thread->state = PREEMPTED;
				fSchedulingData.AddPreemption(thread->thread,
					fState.LastEventTime());
			}
		}
	}

	void _HandleThreadEnqueuedInRunQueue(thread_enqueued_in_run_queue* event)
	{
		_UpdateLastEventTime(event->time);

		Model::ThreadSchedulingState* thread = fState.LookupThread(
			event->thread);
		if (thread == NULL) {
			printf("Enqueued in run queue event for unknown thread: %" B_PRId32
				"\n", event->thread);
			return;
		}

		if (thread->state == RUNNING || thread->state == STILL_RUNNING) {
			// Thread was running and is reentered into the run queue. This
			// is done by the scheduler, if the thread remains ready.
			thread->state = STILL_RUNNING;
		} else {
			// Thread was waiting and is ready now.
			nanotime_t diffTime = fState.LastEventTime() - thread->lastTime;
			if (thread->waitObject != NULL) {
				thread->waitObject->AddWait(diffTime);
				thread->waitObject = NULL;
			}

			fSchedulingData.AddLatency(thread->thread, fState.LastEventTime());
			thread->lastTime = fState.LastEventTime();
			thread->state = READY;
		}
	}

	void _HandleThreadRemovedFromRunQueue(thread_removed_from_run_queue* event)
	{
		_UpdateLastEventTime(event->time);

		Model::ThreadSchedulingState* thread = fState.LookupThread(
			event->thread);
		if (thread == NULL) {
			printf("Removed from run queue event for unknown thread: %" B_PRId32
				"\n", event->thread);
			return;
		}

		// This really only happens when the thread priority is changed
		// while the thread is ready.
		fSchedulingData.AddUnspecifiedWait(thread->thread,
			fState.LastEventTime());

		thread->lastTime = fState.LastEventTime();
		thread->state = WAITING;
	}

private:
	Model::SchedulingState	fState;
	SchedulingData			fSchedulingData;
	nanotime_t				fStartTime;
	nanotime_t				fEndTime;
	uint32					fNSecsPerPixel;
	BPoint					fLastMousePos;
	Listener*				fListener;

	rgb_color				fActivityColors[ACTIVITY_COLOR_COUNT];
	rgb_color				fActivitySelectedColors[ACTIVITY_COLOR_COUNT];
};


class MainWindow::SchedulingPage::ViewPort : public BaseView,
	private HeaderListener, private SchedulingView::Listener {
public:
	ViewPort(HeaderView* headerView, ThreadsView* threadsView,
		SchedulingView* schedulingView, FontInfo& fontInfo,
		ListSelectionModel* filterModel)
		:
		BaseView("viewport", fontInfo, filterModel),
		fHeaderView(headerView),
		fThreadsView(threadsView),
		fSchedulingView(schedulingView)
	{
		AddChild(threadsView);
		AddChild(schedulingView);

		fSchedulingView->SetListener(this);

		HeaderModel* headerModel = fHeaderView->Model();

		Header* header = new Header((int32)fThreadsView->PreferredSize().width,
			(int32)fThreadsView->MinSize().width,
			(int32)fThreadsView->MaxSize().width,
			(int32)fThreadsView->PreferredSize().width, 0);
		header->SetValue("Thread");
		headerModel->AddHeader(header);
		header->AddListener(this);

		header = new Header(100, 100, 10000, 200, 1);
			// TODO: Set header width correctly!
		header->SetValue("Activity");
		header->SetHeaderRenderer(new TimelineHeaderRenderer);
		headerModel->AddHeader(header);
//		header->AddListener(this);
	}

	~ViewPort()
	{
	}

	void RemoveListeners()
	{
		fHeaderView->Model()->HeaderAt(0)->RemoveListener(this);
	}

	void UpdateScrollBars()
	{
		float height = Frame().Height();
		float dataHeight = std::max(height, fSchedulingView->MinSize().height);

		fSchedulingView->UpdateScrollBar();

		if (BScrollBar* scrollBar = ScrollBar(B_VERTICAL)) {
			float range = dataHeight - height;
			if (range > 0) {
				scrollBar->SetRange(0, range);
				scrollBar->SetProportion(
					(height + 1) / (dataHeight + 1));
				scrollBar->SetSteps(fFontInfo.lineHeight, height + 1);
			} else {
				scrollBar->SetRange(0, 0);
				scrollBar->SetProportion(1);
			}
		}
	}

	virtual BSize MinSize()
	{
		return BSize(10, 10);
	}

	virtual BSize MaxSize()
	{
		return BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
	}

	BSize PreferredSize()
	{
		BSize threadsViewSize(fThreadsView->PreferredSize());
		BSize schedulingViewSize(fSchedulingView->PreferredSize());
		return BSize(BLayoutUtils::AddDistances(
				threadsViewSize.width + kViewSeparationMargin,
				schedulingViewSize.width),
			std::max(threadsViewSize.height, schedulingViewSize.height));
	}

	void DoLayout()
	{
		float width = Bounds().Width();
		float height = fThreadsView->MinSize().Height();

		float threadsViewWidth = 0;
		if (fHeaderView->Model()->HeaderAt(0) != NULL)
			threadsViewWidth = fHeaderView->HeaderFrame(0).Width();
		threadsViewWidth = std::max(threadsViewWidth,
			fThreadsView->MinSize().width);
		threadsViewWidth = std::min(threadsViewWidth,
			fThreadsView->MaxSize().width);

		float schedulingViewLeft = threadsViewWidth + 1 + kViewSeparationMargin;
		float schedulingViewWidth = width - schedulingViewLeft;

		fThreadsView->MoveTo(0, 0);
		fThreadsView->ResizeTo(threadsViewWidth, height);

		fSchedulingView->MoveTo(schedulingViewLeft, 0);
		fSchedulingView->ResizeTo(schedulingViewWidth, height);

		if (Header* header = fHeaderView->Model()->HeaderAt(1)) {
			float headerWidth = schedulingViewWidth + 1 + kViewSeparationMargin;
			header->SetMinWidth(headerWidth);
			header->SetMaxWidth(headerWidth);
			header->SetPreferredWidth(headerWidth);
			header->SetWidth(headerWidth);
		}

		UpdateScrollBars();
	}

private:
	virtual void HeaderWidthChanged(Header* header)
	{
		if (header->ModelIndex() == 0)
			InvalidateLayout();
	}

	virtual void DataWidthChanged()
	{
	}

	virtual void DataRangeChanged()
	{
		Header* header = fHeaderView->Model()->HeaderAt(1);
		if (header == NULL)
			return;

		nanotime_t startTime;
		nanotime_t endTime;
		fSchedulingView->GetDataRange(startTime, endTime);
		TimeRange* range = new(std::nothrow) TimeRange(startTime, endTime);
		if (range != NULL) {
			header->SetValue(BVariant(range, 'time'));
			range->ReleaseReference();
		}
	}

private:
	HeaderView*		fHeaderView;
	ThreadsView*	fThreadsView;
	SchedulingView*	fSchedulingView;
};


MainWindow::SchedulingPage::SchedulingPage(MainWindow* parent)
	:
	BGroupView(B_VERTICAL),
	fParent(parent),
	fModel(NULL),
	fScrollView(NULL),
	fViewPort(NULL),
	fThreadsView(NULL),
	fSchedulingView(NULL),
	fFilterModel(),
	fSelectionModel()
{
	SetName("Scheduling");

	be_plain_font->GetHeight(&fFontInfo.fontHeight);
	fFontInfo.lineHeight = ceilf(fFontInfo.fontHeight.ascent)
		+ ceilf(fFontInfo.fontHeight.descent);

	HeaderView* headerView = new HeaderView;
	BView* scrollChild = BLayoutBuilder::Group<>(B_VERTICAL)
		.Add(headerView)
		.Add(fViewPort = new ViewPort(headerView,
			fThreadsView = new ThreadsView(fFontInfo, &fFilterModel,
				&fSelectionModel),
			fSchedulingView = new SchedulingView(fFontInfo, &fFilterModel,
				&fSelectionModel),
			fFontInfo, &fFilterModel)).View();
	;
	scrollChild->SetFlags(scrollChild->Flags() | B_SCROLL_VIEW_AWARE);

	AddChild(fScrollView = new BScrollView("scroll", scrollChild, 0, true,
		true));

	fScrollView->ScrollBar(B_HORIZONTAL)->SetTarget(fSchedulingView);
	fScrollView->ScrollBar(B_VERTICAL)->SetTarget(fViewPort);
	fViewPort->UpdateScrollBars();
}


MainWindow::SchedulingPage::~SchedulingPage()
{
	fViewPort->RemoveListeners();
	fThreadsView->RemoveListeners();
	fSchedulingView->RemoveListeners();
}


void
MainWindow::SchedulingPage::SetModel(Model* model)
{
	if (model == fModel)
		return;

	fSelectionModel.Clear();
	fFilterModel.Clear();

	if (fModel != NULL) {
	}

	fModel = model;

	if (fModel != NULL) {
		fFilterModel.SelectItems(0, fModel->CountThreads(), false);
	}

	fViewPort->SetModel(fModel);
	fThreadsView->SetModel(fModel);
	fSchedulingView->SetModel(fModel);
}