/*
 * Copyright 1999-2009 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Jeremy Friesner
 */
#ifndef _COMMAND_ACTUATORS_H
#define _COMMAND_ACTUATORS_H


#include <Message.h>
#include <String.h>
#include <Archivable.h>
#include <List.h>
#include <InputServerFilter.h>


struct key_map;

class CommandActuator;


// Factory function: Given a text string, allocates and returns a
// CommandActuator. Returns NULL on failure (usually a parse error)
extern CommandActuator* CreateCommandActuator(const char* command);

// This file contains various CommandActuator classes. Each CommandActuator
// contains code to do something. They're functor objects, really. The input
// server add-on will execute the CommandActuator associated with a key combo
// when that key combo is detected.

// The abstract base class. Defines the interface.
class _EXPORT CommandActuator;
class CommandActuator : public BArchivable {
public:
								CommandActuator(int32 argc, char** argv);
								CommandActuator(BMessage* from);

		// Called by the InputFilter whenever a key is pressed or depressed.
		// It's important to ensure that this method returns quickly, as the
		// input_server will block while it executes. (keyMessage) is the BMessage
		// that triggered this call. (outList) is a BList that additional input
		// events may be added to. If (*asyncData) is set to non-NULL,
		// KeyEventAsync() will be called asynchronously with (asyncData) as
		// the argument. Returns the filter_result to be given back to the
		// input_server. (Defaults to B_SKIP_MESSAGE)
		virtual filter_result	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** asyncData,
									BMessage* mouseMessage)
								{ return B_SKIP_MESSAGE; }

		// Called in a separate thread if (*setAsyncData) was set to non-NULL
		// in KeyEvent(). Defaults to a no-op.
		virtual void 			KeyEventAsync(const BMessage* keyupMessage,
									void* asyncData) {}

		virtual status_t 		Archive(BMessage* into, bool deep = true)
									const;
};


// This is the most common thing to do--launch a process.
class _EXPORT LaunchCommandActuator;
class LaunchCommandActuator : public CommandActuator {
public:
								LaunchCommandActuator(int32 argc, char** argv);
								LaunchCommandActuator(BMessage* from);
								~LaunchCommandActuator();

		virtual	status_t 		Archive(BMessage* into, bool deep = true)
									const;
		static	BArchivable*	Instantiate(BMessage* from);
		virtual filter_result 	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);
		virtual void 			KeyEventAsync(const BMessage* keyMessage,
									void* asyncData);

private:
				bool 			_GetNextWord(char** setBegin,
									char** setEnd) const;

				char**			fArgv;
				int32			fArgc;
};


// Stupid actuator--just calls beep().
class _EXPORT BeepCommandActuator;
class BeepCommandActuator : public CommandActuator {
public:
								BeepCommandActuator(int32 argc, char** argv);
								BeepCommandActuator(BMessage* from);
								~BeepCommandActuator();

		virtual	filter_result	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);
		virtual	status_t 		Archive(BMessage* into, bool deep = true)
									const;
		static	BArchivable*	Instantiate(BMessage* from);
};


// This class will insert a string of keystrokes into the input stream.
class _EXPORT KeyStrokeSequenceCommandActuator;
class KeyStrokeSequenceCommandActuator : public CommandActuator {
public:
								KeyStrokeSequenceCommandActuator(int32 argc,
									char** argv);
								KeyStrokeSequenceCommandActuator(
									BMessage* from);
								~KeyStrokeSequenceCommandActuator();

		virtual	filter_result	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);
		virtual	status_t 		Archive(BMessage* into, bool deep = true)
									const;
		static	BArchivable*	Instantiate(BMessage * from);

private:
				void			_GenerateKeyCodes();
				int32 			_LookupKeyCode(key_map* map, char* keys,
									int32 offsets[128], char key,
									uint8* setStates, int32& setModifier,
									int32 setTo) const;
				void 			_SetStateBit(uint8* setStates, uint32 key,
									bool on = true) const;

				uint8* 			fStates;
				int32* 			fKeyCodes;
				int32* 			fModCodes;
				BString 		fSequence;
				BList 			fOverrides;
				BList 			fOverrideOffsets;
				BList 			fOverrideModifiers;
				BList 			fOverrideKeyCodes;
};


// This class will insert a string of keystrokes into the input stream.
class _EXPORT MIMEHandlerCommandActuator;
class MIMEHandlerCommandActuator : public CommandActuator {
public:
								MIMEHandlerCommandActuator(int32 argc,
									char** argv);
								MIMEHandlerCommandActuator(BMessage* from);
								~MIMEHandlerCommandActuator();

		virtual	filter_result 	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);
		virtual	void 			KeyEventAsync(const BMessage* keyupMessage,
									void* asyncData);
		virtual	status_t 		Archive(BMessage * into,
									bool deep = true) const;
		static	BArchivable* 	Instantiate(BMessage* from);

private:
				BString 		fMimeType;
};


// Abstract base class for actuators that affect mouse buttons
class _EXPORT MouseCommandActuator;
class MouseCommandActuator : public CommandActuator {
public:
								MouseCommandActuator(int32 argc, char** argv);
								MouseCommandActuator(BMessage* from);
								~MouseCommandActuator();

		virtual	status_t		Archive(BMessage* into, bool deep = true)
									const;

protected:
				int32			_GetWhichButtons() const;
				void 			_GenerateMouseButtonEvent(bool mouseDown,
									const BMessage* keyMessage, BList* outList,
									BMessage* mouseMessage);

private:
				int32			fWhichButtons;
};


// This class sends a single mouse down event when activated, causing the mouse
// pointer to enter a "sticky down" state. Good for some things(like dragging).
class _EXPORT MouseDownCommandActuator;
class MouseDownCommandActuator : public MouseCommandActuator {
public:
								MouseDownCommandActuator(int32 argc,
									char** argv);
								MouseDownCommandActuator(BMessage* from);
								~MouseDownCommandActuator();

		virtual	filter_result	KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);
		virtual	status_t 		Archive(BMessage* into, bool deep = true)
									const;
		static	BArchivable*	Instantiate(BMessage* from);
};


// This class sends a single mouse down up when activated, releasing any
// previously set "sticky down" state. Good for some things (like dragging).
class _EXPORT MouseUpCommandActuator;
class MouseUpCommandActuator : public MouseCommandActuator {
public:
								MouseUpCommandActuator(int32 argc,
									char** argv);
								MouseUpCommandActuator(BMessage* from);
								~MouseUpCommandActuator();

	virtual filter_result 		KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);

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


// This class will send B_MOUSE_UP and B_MOUSE_DOWN events whenever B_KEY_UP or
// B_KEY_DOWN events are detected for its key This way a key can act sort of
// like a mouse button.
class _EXPORT MouseButtonCommandActuator;
class MouseButtonCommandActuator : public MouseCommandActuator {
public:
								MouseButtonCommandActuator(int32 argc,
									char** argv);
								MouseButtonCommandActuator(BMessage* from);
								~MouseButtonCommandActuator();

	virtual filter_result 		KeyEvent(const BMessage* keyMessage,
									BList* outList, void** setAsyncData,
									BMessage* mouseMessage);

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

private:
			bool 				fKeyDown ;
};


// Base class for some actuators that control the position of the mouse pointer
class _EXPORT MoveMouseCommandActuator;
class MoveMouseCommandActuator : public CommandActuator {
public:
								MoveMouseCommandActuator(int32 argc,
									char** argv);
								MoveMouseCommandActuator(BMessage* from);
								~MoveMouseCommandActuator();

	virtual	status_t			Archive(BMessage* into, bool deep) const;

protected:
			void 				CalculateCoords(float& setX, float& setY)
									const;
			BMessage* 			CreateMouseMessage(const BMessage* original,
									BPoint where, BList* outList) const;

private:
			void 				_ParseArg(const char* arg, float& setPercent,
									float& setPixels) const;

			float 				fXPercent;
			float 				fYPercent;
			float 				fXPixels;
			float 				fYPixels;
};


// Actuator that specifies multiple sub-actuators to be executed in series
class _EXPORT MultiCommandActuator;
class MultiCommandActuator : public CommandActuator {
public:
								MultiCommandActuator(int32 argc, char** argv);
								MultiCommandActuator(BMessage* from);
								~MultiCommandActuator();

	virtual status_t			Archive(BMessage* into, bool deep) const;
	virtual filter_result		KeyEvent(const BMessage* keyMessage,
									BList* outList, void** asyncData,
									BMessage* mouseMessage);
	virtual void				KeyEventAsync(const BMessage* keyupMessage,
									void * asyncData);
	static	BArchivable*		Instantiate(BMessage* from);

private:
			BList				fSubActuators;
};


// Actuator for moving a mouse relative to its current position
class _EXPORT MoveMouseToCommandActuator;
class MoveMouseToCommandActuator : public MoveMouseCommandActuator {
public:
								MoveMouseToCommandActuator(int32 argc,
									char** argv);
								MoveMouseToCommandActuator(BMessage* from);
								~MoveMouseToCommandActuator();

	virtual	filter_result		KeyEvent(const BMessage* keyMessage, BList* outList
									, void** setAsyncData,
									BMessage* mouseMessage);

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


// Actuator for moving a mouse relative to its current position
class _EXPORT MoveMouseByCommandActuator;
class MoveMouseByCommandActuator : public MoveMouseCommandActuator {
public:
									MoveMouseByCommandActuator(int32 argc,
										char** argv);
									MoveMouseByCommandActuator(BMessage* from);
									~MoveMouseByCommandActuator();

	virtual filter_result 			KeyEvent(const BMessage* keyMessage,
										BList* outList, void** setAsyncData,
										BMessage* mouseMessage);
	virtual status_t 				Archive(BMessage * into, bool deep = true)
										const;
	static 	BArchivable*			Instantiate(BMessage * from);
};


// Actuator to send BMessage to an application - written by Daniel Wesslen
class _EXPORT SendMessageCommandActuator;
class SendMessageCommandActuator : public CommandActuator {
public:
									SendMessageCommandActuator(int32 argc,
										char** argv);
									SendMessageCommandActuator(BMessage* from);
									~SendMessageCommandActuator();

	virtual filter_result			KeyEvent(const BMessage* keyMessage,
										BList* outList, void** setAsyncData,
										BMessage* mouseMessage);
	virtual void					KeyEventAsync(const BMessage* keyupMessage,
										void* asyncData);
	virtual status_t				Archive(BMessage* into, bool deep = true)
										const;
	static 	BArchivable*			Instantiate(BMessage * from);

private:
			void					_ParseFloatArgs(float* outArgs, int maxArgs
										, const char* str) const;

			BString					fSignature;
			BMessage				fSendMessage;
};


#endif	// _COMMAND_ACTUATORS_H