haiku.git

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


#include <stdio.h>

#include <new>

#include <CheckBox.h>
#include <GroupView.h>

#include "model/Model.h"
#include "table/TableColumns.h"
#include "table/TreeTable.h"


#define ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE						\
	template<typename ModelType, typename WaitObjectGroupType,	\
		typename WaitObjectType>
#define ABSTRACT_WAIT_OBJECTS_PAGE_CLASS	\
	AbstractWaitObjectsPage<ModelType, WaitObjectGroupType,	WaitObjectType>


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
class AbstractWaitObjectsPage : public BGroupView, protected TreeTableListener {
public:
								AbstractWaitObjectsPage();
	virtual						~AbstractWaitObjectsPage();

			void				SetModel(ModelType* model);

	virtual	void				MessageReceived(BMessage* message);

	virtual	void				AttachedToWindow();

protected:
			class WaitObjectsTreeModel;

			enum {
				MSG_ABSTRACT_WAIT_OBJECTS_GROUP_BY_NAME		= 'awog'
			};

protected:
			void				_UpdateTreeModel();

protected:
			TreeTable*			fWaitObjectsTree;
			WaitObjectsTreeModel* fWaitObjectsTreeModel;
			ModelType*			fModel;
			BCheckBox*			fGroupByNameCheckBox;
			bool				fGroupByName;


// #pragma mark - WaitObjectsTreeModel (inner class)


class WaitObjectsTreeModel : public TreeTableModel {
public:
	WaitObjectsTreeModel(ModelType* model, bool groupByName)
		:
		fModel(model),
		fRootNode(NULL)
	{
		fRootNode = new RootNode(fModel, groupByName);
	}

	~WaitObjectsTreeModel()
	{
		delete fRootNode;
	}

	virtual void* Root() const
	{
		return fRootNode;
	}

	virtual int32 CountChildren(void* parent) const
	{
		return ((Node*)parent)->CountChildren();
	}

	virtual void* ChildAt(void* parent, int32 index) const
	{
		return ((Node*)parent)->ChildAt(index);
	}

	virtual int32 CountColumns() const
	{
		return 6;
	}

	virtual bool GetValueAt(void* object, int32 columnIndex, BVariant& value)
	{
		return ((Node*)object)->GetValueAt(columnIndex, value);
	}

private:
	struct Node {
		virtual ~Node() {}

		virtual const char* Name() const = 0;
		virtual uint32 Type() const = 0;
		virtual addr_t Object() const = 0;
		virtual addr_t ReferencedObject() const = 0;
		virtual int64 Waits() const = 0;
		virtual nanotime_t TotalWaitTime() const = 0;

		virtual int32 CountChildren() const = 0;
		virtual void* ChildAt(int32 index) const = 0;

		static int CompareByName(const Node* a, const Node* b)
		{
			int cmp = (int)a->Type() - (int)b->Type();
			return cmp == 0 ? strcmp(a->Name(), b->Name()) : cmp;
		}

		bool GetValueAt(int32 columnIndex, BVariant& value)
		{
			switch (columnIndex) {
				case 0:
					value.SetTo(wait_object_type_name(Type()),
						B_VARIANT_DONT_COPY_DATA);
					return true;
				case 1:
					value.SetTo(Name(), B_VARIANT_DONT_COPY_DATA);
					return true;
				case 2:
				{
					addr_t object = Object();
					if (object == 0)
						return false;

					char buffer[20];
					snprintf(buffer, sizeof(buffer), "%#lx", object);
					value.SetTo(buffer);
					return true;
				}
				case 3:
				{
					addr_t object = ReferencedObject();
					if (object == 0)
						return false;

					char buffer[20];
					snprintf(buffer, sizeof(buffer), "%#lx", object);
					value.SetTo(buffer);
					return true;
				}
				case 4:
					value.SetTo(Waits());
					return true;
				case 5:
					value.SetTo(TotalWaitTime());
					return true;
				default:
					return false;
			}
		}
	};

	struct ObjectNode : Node {
		WaitObjectType* object;

		ObjectNode(WaitObjectType* object)
			:
			object(object)
		{
		}

		virtual const char* Name() const
		{
			return object->Name();
		}

		virtual uint32 Type() const
		{
			return object->Type();
		}

		virtual addr_t Object() const
		{
			return object->Object();
		}

		virtual addr_t ReferencedObject() const
		{
			return object->ReferencedObject();
		}

		virtual int64 Waits() const
		{
			return object->Waits();
		}

		virtual nanotime_t TotalWaitTime() const
		{
			return object->TotalWaitTime();
		}

		virtual int32 CountChildren() const
		{
			return 0;
		}

		virtual void* ChildAt(int32 index) const
		{
			return NULL;
		}
	};

	// For GCC 2
	friend struct ObjectNode;

	struct GroupNode : Node {
		WaitObjectGroupType*	group;
		BObjectList<ObjectNode>	objectNodes;

		GroupNode(WaitObjectGroupType* group)
			:
			group(group)
		{
			int32 count = group->CountWaitObjects();
			for (int32 i = 0; i < count; i++) {
				WaitObjectType* waitObject = group->WaitObjectAt(i);
				if (!objectNodes.AddItem(new ObjectNode(waitObject)))
					throw std::bad_alloc();
			}
		}

		virtual const char* Name() const
		{
			return group->Name();
		}

		virtual uint32 Type() const
		{
			return group->Type();
		}

		virtual addr_t Object() const
		{
			return group->Object();
		}

		virtual addr_t ReferencedObject() const
		{
			return 0;
		}

		virtual int64 Waits() const
		{
			return group->Waits();
		}

		virtual nanotime_t TotalWaitTime() const
		{
			return group->TotalWaitTime();
		}

		virtual int32 CountChildren() const
		{
			return objectNodes.CountItems();
		}

		virtual void* ChildAt(int32 index) const
		{
			return objectNodes.ItemAt(index);
		}
	};

	// For GCC 2
	friend struct GroupNode;

	struct NodeContainerNode : Node {
		NodeContainerNode()
			:
			fChildren(20)
		{
		}

		NodeContainerNode(BObjectList<Node>& nodes)
			:
			fChildren(20)
		{
			for (int32 index = 0; index < nodes.CountItems(); index++)
				fChildren.AddItem(nodes.ItemAt(index));

			// compute total waits and total wait time
			fWaits = 0;
			fTotalWaitTime = 0;

			for (int32 i = 0; Node* node = fChildren.ItemAt(i); i++) {
				fWaits += node->Waits();
				fTotalWaitTime += node->TotalWaitTime();
			}
		}

		virtual const char* Name() const
		{
			Node* child = fChildren.ItemAt(0);
			return child != NULL ? child->Name() : "";
		}

		virtual uint32 Type() const
		{
			Node* child = fChildren.ItemAt(0);
			return child != NULL ? child->Type() : 0;
		}

		virtual addr_t Object() const
		{
			return 0;
		}

		virtual addr_t ReferencedObject() const
		{
			return 0;
		}

		virtual int64 Waits() const
		{
			return fWaits;
		}

		virtual nanotime_t TotalWaitTime() const
		{
			return fTotalWaitTime;
		}

		virtual int32 CountChildren() const
		{
			return fChildren.CountItems();
		}

		virtual void* ChildAt(int32 index) const
		{
			return fChildren.ItemAt(index);
		}

	protected:
		BObjectList<Node, true> fChildren;
		int64				fWaits;
		nanotime_t			fTotalWaitTime;
	};

	struct RootNode : public NodeContainerNode {
		ModelType*			model;

		RootNode(ModelType* model, bool groupByName)
			:
			model(model)
		{
			// create nodes for the wait object groups
			BObjectList<Node, true> tempChildren;
			BObjectList<Node, true>& children
				= groupByName ? tempChildren : NodeContainerNode::fChildren;
			int32 count = model->CountWaitObjectGroups();
			for (int32 i = 0; i < count; i++) {
				WaitObjectGroupType* group = model->WaitObjectGroupAt(i);
				if (!children.AddItem(_CreateGroupNode(group)))
					throw std::bad_alloc();
			}

			// If we shall group the nodes by name, we create grouping nodes.
			if (groupByName) {
				if (children.CountItems() < 2) {
					NodeContainerNode::fChildren.AddList(&children);
					children.MakeEmpty(false);
					return;
				}

				// sort the nodes by name
				children.SortItems(&Node::CompareByName);

				// create groups
				int32 nodeCount = children.CountItems();
				BObjectList<Node> nameGroup;
				Node* previousNode = children.ItemAt(0);
				int32 groupNodeIndex = 0;
				for (int32 i = 1; i < nodeCount; i++) {
					Node* node = children.ItemAt(i);
					if (strcmp(node->Name(), previousNode->Name())) {
						// create the group -- or just add the node, if it's
						// the only one
						if (nameGroup.CountItems() > 1) {
							NodeContainerNode::fChildren.AddItem(
								new NodeContainerNode(nameGroup));
						} else
							NodeContainerNode::fChildren.AddItem(previousNode);

						nameGroup.MakeEmpty();
						groupNodeIndex = i;
					}

					// add the node
					nameGroup.AddItem(node);

					previousNode = node;
				}
			}

			tempChildren.MakeEmpty(false);
		}

	private:
		static Node* _CreateGroupNode(WaitObjectGroupType* group)
		{
			// If the group has only one object, just create an object node.
			if (group->CountWaitObjects() == 1)
				return new ObjectNode(group->WaitObjectAt(0));

			return new GroupNode(group);
		}
	};

private:
	ModelType*	fModel;
	RootNode*	fRootNode;
};	// WaitObjectsTreeModel

};	// AbstractWaitObjectsPage


// #pragma mark - WaitObjectsPage


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::AbstractWaitObjectsPage()
	:
	BGroupView(B_VERTICAL, 10),
	fWaitObjectsTree(NULL),
	fWaitObjectsTreeModel(NULL),
	fModel(NULL),
	fGroupByNameCheckBox(NULL),
	fGroupByName(false)
{
	SetName("Wait objects");

	fWaitObjectsTree = new TreeTable("wait object list", 0);
	AddChild(fWaitObjectsTree->ToView());

	fGroupByNameCheckBox = new BCheckBox("group by name checkbox",
		"Group by name", new BMessage(MSG_ABSTRACT_WAIT_OBJECTS_GROUP_BY_NAME));
	fGroupByNameCheckBox->SetValue(
		fGroupByName ? B_CONTROL_ON : B_CONTROL_OFF);
	AddChild(fGroupByNameCheckBox);

	fWaitObjectsTree->AddColumn(new StringTableColumn(0, "Type", 80, 40, 1000,
		B_TRUNCATE_END, B_ALIGN_LEFT));
	fWaitObjectsTree->AddColumn(new StringTableColumn(1, "Name", 80, 40, 1000,
		B_TRUNCATE_END, B_ALIGN_LEFT));
	fWaitObjectsTree->AddColumn(new StringTableColumn(2, "Object", 80, 40, 1000,
		B_TRUNCATE_END, B_ALIGN_LEFT));
	fWaitObjectsTree->AddColumn(new StringTableColumn(3, "Referenced", 80, 40,
		1000, B_TRUNCATE_END, B_ALIGN_LEFT));
	fWaitObjectsTree->AddColumn(new Int64TableColumn(4, "Waits", 80, 20,
		1000, B_TRUNCATE_END, B_ALIGN_RIGHT));
	fWaitObjectsTree->AddColumn(new NanotimeTableColumn(5, "Wait time", 80,
		20, 1000, false, B_TRUNCATE_END, B_ALIGN_RIGHT));

	fWaitObjectsTree->AddTreeTableListener(this);
}


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::~AbstractWaitObjectsPage()
{
	fWaitObjectsTree->SetTreeTableModel(NULL);
	delete fWaitObjectsTreeModel;
}


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
void
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::SetModel(ModelType* model)
{
	if (model == fModel)
		return;

	if (fModel != NULL) {
		fWaitObjectsTree->SetTreeTableModel(NULL);
		delete fWaitObjectsTreeModel;
		fWaitObjectsTreeModel = NULL;
	}

	fModel = model;

	if (fModel != NULL)
		_UpdateTreeModel();
}


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
void
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_ABSTRACT_WAIT_OBJECTS_GROUP_BY_NAME:
			fGroupByName = fGroupByNameCheckBox->Value() == B_CONTROL_ON;
			_UpdateTreeModel();
			break;
		default:
			BGroupView::MessageReceived(message);
			break;
	}
}


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
void
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::AttachedToWindow()
{
	fGroupByNameCheckBox->SetTarget(this);
}


ABSTRACT_WAIT_OBJECTS_PAGE_TEMPLATE
void
ABSTRACT_WAIT_OBJECTS_PAGE_CLASS::_UpdateTreeModel()
{
	if (fModel != NULL) {
		fWaitObjectsTree->SetTreeTableModel(NULL);
		delete fWaitObjectsTreeModel;
		fWaitObjectsTreeModel = NULL;
	}

	if (fModel != NULL) {
		try {
			fWaitObjectsTreeModel = new WaitObjectsTreeModel(fModel,
				fGroupByName);
		} catch (std::bad_alloc&) {
			// TODO: Report error!
		}
		fWaitObjectsTree->SetTreeTableModel(fWaitObjectsTreeModel);
		fWaitObjectsTree->ResizeAllColumnsToPreferred();
	}
}


#endif	// ABSTRACT_WAIT_OBJECTS_PAGE_H