/*
 * Copyright 2001-2009, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _SHELF_H
#define _SHELF_H


#include <Dragger.h>
#include <Handler.h>
#include <List.h>
#include <Locker.h>


class BDataIO;
class BPoint;
class BView;
class BEntry;
class _BZombieReplicantView_;
struct entry_ref;

namespace BPrivate {
	struct replicant_data;
	class ShelfContainerViewFilter;
};


class BShelf : public BHandler {
public:
								BShelf(BView* view, bool allowDrags = true,
									const char* shelfType = NULL);
								BShelf(const entry_ref* ref, BView* view,
									bool allowDrags = true,
									const char* shelfType = NULL);
								BShelf(BDataIO* stream, BView* view,
									bool allowDrags = true,
									const char* shelfType = NULL);
								BShelf(BMessage* archive);
	virtual						~BShelf();

	static BArchivable*			Instantiate(BMessage* archive);
	virtual	status_t			Archive(BMessage* archive,
									bool deep = true) const;

	virtual	void				MessageReceived(BMessage* message);
			status_t			Save();
	virtual	void				SetDirty(bool state);
			bool				IsDirty() const;

	virtual	BHandler*			ResolveSpecifier(BMessage* message,
									int32 index, BMessage* specifier,
									int32 form, const char* property);
	virtual	status_t			GetSupportedSuites(BMessage* data);

	virtual	status_t			Perform(perform_code code, void* data);

			bool				AllowsDragging() const;
			void				SetAllowsDragging(bool state);
			bool				AllowsZombies() const;
			void				SetAllowsZombies(bool state);
			bool				DisplaysZombies() const;
			void				SetDisplaysZombies(bool state);
			bool				IsTypeEnforced() const;
			void				SetTypeEnforced(bool state);

			status_t			SetSaveLocation(BDataIO* stream);
			status_t			SetSaveLocation(const entry_ref* ref);
			BDataIO*			SaveLocation(entry_ref* ref) const;

			status_t			AddReplicant(BMessage* archive,
									BPoint location);
			status_t			DeleteReplicant(BView* replicant);
			status_t			DeleteReplicant(BMessage* archive);
			status_t			DeleteReplicant(int32 index);
			int32				CountReplicants() const;
			BMessage*			ReplicantAt(int32 index, BView** view = NULL,
									uint32* uid = NULL,
									status_t* perr = NULL) const;
			int32				IndexOf(const BView* replicantView) const;
			int32				IndexOf(const BMessage* archive) const;
			int32				IndexOf(uint32 id) const;

protected:
	virtual	bool				CanAcceptReplicantMessage(
									BMessage* archive) const;
	virtual	bool				CanAcceptReplicantView(BRect,
									BView*, BMessage*) const;
	virtual	BPoint				AdjustReplicantBy(BRect, BMessage*) const;

	virtual	void				ReplicantDeleted(int32 index,
									const BMessage* archive,
									const BView *replicant);

private:
	// FBC padding and forbidden methods
	virtual	void				_ReservedShelf2();
	virtual	void				_ReservedShelf3();
	virtual	void				_ReservedShelf4();
	virtual	void				_ReservedShelf5();
	virtual	void				_ReservedShelf6();
	virtual	void				_ReservedShelf7();
	virtual	void				_ReservedShelf8();

								BShelf(const BShelf& other);
			BShelf&				operator=(const BShelf& other);

private:
	friend class BPrivate::ShelfContainerViewFilter;

			status_t			_Archive(BMessage* data) const;
			void				_InitData(BEntry* entry, BDataIO* stream,
									BView* view, bool allowDrags);
			status_t			_DeleteReplicant(
									BPrivate::replicant_data* replicant);
			status_t			_AddReplicant(BMessage* data,
									BPoint* location, uint32 uniqueID);
			BView*				_GetReplicant(BMessage* data, BView* view,
									const BPoint& point, BDragger*& dragger,
									BDragger::relation& relation);
			_BZombieReplicantView_* _CreateZombie(BMessage *data,
									BDragger *&dragger);

			status_t			_GetProperty(BMessage* message,
									BMessage* reply);
	static	void				_GetReplicantData(BMessage* message,
									BView* view, BView*& replicant,
									BDragger*& dragger,
									BDragger::relation& relation);
	static	BArchivable*		_InstantiateObject(BMessage* archive,
									image_id* image);

private:
			BView*				fContainerView;
			BDataIO*			fStream;
			BEntry*				fEntry;
			BList				fReplicants;
			BPrivate::ShelfContainerViewFilter* fFilter;
			uint32				fGenCount;
			bool				fAllowDragging;
			bool				fDirty;
			bool				fDisplayZombies;
			bool				fAllowZombies;
			bool				fTypeEnforced;

			uint32				_reserved[8];
};

#endif	/* _SHELF_H */