haiku.git

/*
 * Copyright 2006-2007, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */

#ifndef STATE_VIEW_H
#define STATE_VIEW_H

#include <View.h>

#include "ViewState.h"

class BMessageFilter;
class Command;
class CommandStack;
class RWLocker;

class StateView : public BView {
 public:
								StateView(BRect frame, const char* name,
										  uint32 resizingMode, uint32 flags);
	virtual						~StateView();

	// BView interface
	virtual	void				AttachedToWindow();
	virtual	void				DetachedFromWindow();
	virtual	void				Draw(BRect updateRect);
	virtual	void				MessageReceived(BMessage* message);

	virtual	void				MouseDown(BPoint where);
	virtual	void				MouseMoved(BPoint where, uint32 transit,
										   const BMessage* dragMessage);
	virtual	void				MouseUp(BPoint where);

	virtual	void				KeyDown(const char* bytes, int32 numBytes);
	virtual	void				KeyUp(const char* bytes, int32 numBytes);

	virtual	status_t			Perform(perform_code code, void* data);
		// Avoids warning about hiding BView::Perform().

	virtual	void				GetPreferredSize(float* width, float* height);

	// StateView interface
			void				SetState(ViewState* state);
			void				UpdateStateCursor();

			void				Draw(BView* into, BRect updateRect);

	virtual	bool				MouseWheelChanged(BPoint where,
												  float x, float y);

			bool				HandleKeyDown(uint32 key, uint32 modifiers);
			bool				HandleKeyUp(uint32 key, uint32 modifiers);

			const mouse_info*	MouseInfo() const
									{ return &fMouseInfo; }

	virtual	void				FilterMouse(BPoint* where) const;

	virtual	ViewState*			StateForDragMessage(const BMessage* message);

			void				SetLocker(RWLocker* locker);
			RWLocker*			Locker() const
									{ return fLocker; }

			void				SetCommandStack(::CommandStack* stack);
			::CommandStack*		CommandStack() const
									{ return fCommandStack; }

			void				SetUpdateTarget(BHandler* target,
												uint32 command);

			void				SetCatchAllEvents(bool catchAll);

			status_t			Perform(Command* command);

 protected:
	virtual	bool				_HandleKeyDown(uint32 key, uint32 modifiers);
	virtual	bool				_HandleKeyUp(uint32 key, uint32 modifiers);

			void				_InstallEventFilter();
			void				_RemoveEventFilter();

			void				_TriggerUpdate();

			BRect				fStartingRect;

			ViewState*			fCurrentState;
			ViewState*			fDropAnticipatingState;
				// the drop anticipation state is some
				// kind of "temporary" state that is
				// used on top of the current state (it
				// doesn't replace it)
			mouse_info			fMouseInfo;

			::CommandStack*		fCommandStack;
			RWLocker*			fLocker;

			BMessageFilter*		fEventFilter;
			bool				fCatchAllEvents;

			BHandler*			fUpdateTarget;
			uint32				fUpdateCommand;
};

#endif // STATE_VIEW_H