1/*
2 * Copyright 1999-2009 Haiku Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 *		Jeremy Friesner
7 */
8
9
10#ifndef CommandActuators_h
11#define CommandActuators_h
12
13#include <Message.h>
14#include <String.h>
15#include <Archivable.h>
16#include <List.h>
17#include <InputServerFilter.h>
18
19#ifndef __HAIKU__
20#ifndef __INTEL__
21#pragma export on
22#endif
23#endif
24
25struct key_map; // declaration
26
27class CommandActuator;
28
29// 	Factory function: Given a text string, allocates and returns a
30//	CommandActuator. Returns NULL on failure (usually a parse error)
31extern CommandActuator* CreateCommandActuator(const char* command);
32
33// 	This file contains various CommandActuator classes. Each CommandActuator
34//	contains code to do something. They're functor objects, really. The input
35//	server add-on will execute the CommandActuator associated with a key combo
36// 	when that key combo is detected.
37
38// The abstract base class. Defines the interface.
39_EXPORT class CommandActuator;
40class CommandActuator : public BArchivable {
41public:
42								CommandActuator(int32 argc, char** argv);
43								CommandActuator(BMessage* from);
44
45		// Called by the InputFilter whenever a key is pressed or depressed.
46		// It's important to ensure that this method returns quickly, as the
47		// input_server will block while it executes. (keyMsg) is the BMessage
48		// that triggered this call. (outlist) is a BList that additional input
49		// events may be added to. If (*asyncData) is set to non-NULL,
50		// KeyEventAsync() will be called asynchronously with (asyncData) as
51		// the argument. Returns the filter_result to be given back to the
52		// input_server. (Defaults to B_SKIP_MESSAGE)
53		virtual filter_result	KeyEvent(const BMessage* keyMsg,
54									BList* outlist, void** asyncData,
55									BMessage* lastMouseMove)
56									{return B_SKIP_MESSAGE;}
57
58		// Called in a separate thread if (*setAsyncData) was set to non-NULL
59		// in KeyEvent(). Defaults to a no-op.
60		virtual void 			KeyEventAsync(const BMessage* keyUpMsg,
61									void* asyncData) {}
62
63		virtual status_t 		Archive(BMessage* into, bool deep = true)
64									const;
65};
66
67
68// This is the most common thing to do--launch a process.
69_EXPORT class LaunchCommandActuator;
70class LaunchCommandActuator : public CommandActuator {
71public:
72								LaunchCommandActuator(int32 argc, char** argv);
73								LaunchCommandActuator(BMessage* from);
74								~LaunchCommandActuator();
75
76		virtual	status_t 		Archive(BMessage* into, bool deep = true)
77									const;
78		static	BArchivable*	Instantiate(BMessage* from);
79		virtual filter_result 	KeyEvent(const BMessage* keyMsg,
80									BList* outlist, void** setAsyncData,
81									BMessage* lastMouseMove);
82		virtual void 			KeyEventAsync(const BMessage* keyMsg,
83									void* asyncData);
84
85private:
86				bool 			_GetNextWord(char** setBegin, char** setEnd)
87									const;
88
89				char**			fArgv;
90				int32			fArgc;
91};
92
93
94// Stupid actuator--just calls beep().
95_EXPORT class BeepCommandActuator;
96class BeepCommandActuator : public CommandActuator {
97public:
98								BeepCommandActuator(int32 argc, char** argv);
99								BeepCommandActuator(BMessage* from);
100								~BeepCommandActuator();
101
102		virtual	filter_result 	KeyEvent(const BMessage* keyMsg,
103									BList* outlist, void** setAsyncData,
104									BMessage* lastMouseMove);
105		virtual status_t 		Archive(BMessage* into, bool deep = true)
106									const;
107		static BArchivable* 	Instantiate(BMessage* from);
108};
109
110
111// This class will insert a string of keystrokes into the input stream.
112_EXPORT class KeyStrokeSequenceCommandActuator;
113class KeyStrokeSequenceCommandActuator : public CommandActuator {
114public:
115								KeyStrokeSequenceCommandActuator(int32 argc,
116									char** argv);
117								KeyStrokeSequenceCommandActuator(
118									BMessage* from);
119								~KeyStrokeSequenceCommandActuator();
120
121		virtual filter_result 	KeyEvent(const BMessage* keyMsg,
122									BList* outlist, void** setAsyncData,
123									BMessage* lastMouseMove);
124		virtual status_t 		Archive(BMessage* into, bool deep = true)
125									const;
126		static 	BArchivable* 	Instantiate(BMessage * from);
127private:
128				void			_GenerateKeyCodes();
129				int32 			_LookupKeyCode(key_map* map, char* keys,
130									int32 offsets[128], char key,
131									uint8* setStates, int32& setMod,
132									int32 setTo) const;
133				void 			_SetStateBit(uint8* setStates, uint32 key,
134									bool on = true) const;
135
136				uint8* 			fStates;
137				int32* 			fKeyCodes;
138				int32* 			fModCodes;
139				BString 		fSequence;
140				BList 			fOverrides;
141				BList 			fOverrideOffsets;
142				BList 			fOverrideModifiers;
143				BList 			fOverrideKeyCodes;
144};
145
146
147// This class will insert a string of keystrokes into the input stream.
148_EXPORT class MIMEHandlerCommandActuator;
149class MIMEHandlerCommandActuator : public CommandActuator {
150public:
151								MIMEHandlerCommandActuator(int32 argc,
152									char** argv);
153								MIMEHandlerCommandActuator(BMessage* from);
154								~MIMEHandlerCommandActuator();
155
156		virtual	filter_result 	KeyEvent(const BMessage* keyMsg,
157									BList* outlist, void** setAsyncData,
158									BMessage* lastMouseMove);
159		virtual void 			KeyEventAsync(const BMessage* keyUpMsg,
160									void* asyncData);
161		virtual status_t 		Archive(BMessage * into, bool deep = true)
162									const;
163		static 	BArchivable* 	Instantiate(BMessage* from);
164
165private:
166				BString 		fMimeType;
167};
168
169
170// Abstract base class for actuators that affect mouse buttons
171_EXPORT class MouseCommandActuator;
172class MouseCommandActuator : public CommandActuator {
173public:
174								MouseCommandActuator(int32 argc, char** argv);
175								MouseCommandActuator(BMessage* from);
176								~MouseCommandActuator();
177
178		virtual	status_t		Archive(BMessage* into, bool deep = true)
179									const;
180
181protected:
182				int32			_GetWhichButtons() const;
183				void 			_GenerateMouseButtonEvent(bool mouseDown,
184									const BMessage* keyMsg, BList* outlist,
185									BMessage* lastMouseMove);
186
187private:
188				int32			fWhichButtons;
189};
190
191
192// This class sends a single mouse down event when activated, causing the mouse
193// pointer to enter a "sticky down" state. Good for some things(like dragging).
194_EXPORT class MouseDownCommandActuator;
195class MouseDownCommandActuator : public MouseCommandActuator {
196public:
197								MouseDownCommandActuator(int32 argc,
198									char** argv);
199								MouseDownCommandActuator(BMessage* from);
200								~MouseDownCommandActuator();
201
202		virtual	filter_result 	KeyEvent(const BMessage* keyMsg,
203									BList* outlist, void** setAsyncData,
204									BMessage* lastMouseMove);
205		virtual	status_t 		Archive(BMessage* into, bool deep = true)
206									const;
207		static	BArchivable * 	Instantiate(BMessage * from);
208};
209
210
211// This class sends a single mouse down up when activated, releasing any
212// previously set "sticky down" state. Good for some things (like dragging).
213_EXPORT class MouseUpCommandActuator;
214class MouseUpCommandActuator : public MouseCommandActuator {
215public:
216								MouseUpCommandActuator(int32 argc,
217									char** argv);
218								MouseUpCommandActuator(BMessage * from);
219								~MouseUpCommandActuator();
220
221	virtual filter_result 		KeyEvent(const BMessage* keyMsg,
222									BList* outlist, void** setAsyncData,
223									BMessage* lastMouseMove);
224
225	virtual status_t 			Archive(BMessage* into, bool deep = true)
226									const;
227	static 	BArchivable* 		Instantiate(BMessage* from);
228};
229
230
231// This class will send B_MOUSE_UP and B_MOUSE_DOWN events whenever B_KEY_UP or
232// B_KEY_DOWN events are detected for its key This way a key can act sort of
233// like a mouse button.
234_EXPORT class MouseButtonCommandActuator;
235class MouseButtonCommandActuator : public MouseCommandActuator {
236public:
237								MouseButtonCommandActuator(int32 argc,
238									char** argv);
239								MouseButtonCommandActuator(BMessage* from);
240								~MouseButtonCommandActuator();
241
242	virtual filter_result 		KeyEvent(const BMessage* keyMsg,
243									BList* outlist, void** setAsyncData,
244									BMessage* lastMouseMove);
245
246	virtual status_t 			Archive(BMessage* into, bool deep = true)
247									const;
248	static 	BArchivable* 		Instantiate(BMessage* from);
249
250private:
251			bool 				fKeyDown ;
252};
253
254
255// Base class for some actuators that control the position of the mouse pointer
256_EXPORT class MoveMouseCommandActuator;
257class MoveMouseCommandActuator : public CommandActuator {
258public:
259								MoveMouseCommandActuator(int32 argc,
260									char** argv);
261								MoveMouseCommandActuator(BMessage* from);
262								~MoveMouseCommandActuator();
263
264	virtual	status_t			Archive(BMessage* into, bool deep) const;
265
266protected:
267			void 				CalculateCoords(float& setX, float& setY)
268									const;
269			BMessage* 			CreateMouseMovedMessage(const BMessage* origMsg
270									, BPoint p, BList* outlist) const;
271
272private:
273			void 				_ParseArg(const char* arg, float& setPercent,
274									float& setPixels) const;
275
276			float 				fXPercent;
277			float 				fYPercent;
278			float 				fXPixels;
279			float 				fYPixels;
280};
281
282
283// Actuator that specifies multiple sub-actuators to be executed in series
284_EXPORT class MultiCommandActuator;
285class MultiCommandActuator : public CommandActuator {
286public:
287								MultiCommandActuator(int32 argc, char** argv);
288								MultiCommandActuator(BMessage* from);
289								~MultiCommandActuator();
290
291	virtual status_t			Archive(BMessage* into, bool deep) const;
292	virtual filter_result		KeyEvent(const BMessage* keyMsg,
293									BList* outlist, void** asyncData,
294									BMessage* lastMouseMove);
295	virtual void				KeyEventAsync(const BMessage* keyUpMsg,
296									void * asyncData);
297	static	BArchivable*		Instantiate(BMessage* from);
298
299private:
300			BList				fSubActuators;
301};
302
303
304// Actuator for moving a mouse relative to its current position
305_EXPORT class MoveMouseToCommandActuator;
306class MoveMouseToCommandActuator : public MoveMouseCommandActuator {
307public:
308								MoveMouseToCommandActuator(int32 argc,
309									char** argv);
310								MoveMouseToCommandActuator(BMessage* from);
311								~MoveMouseToCommandActuator();
312
313	virtual	filter_result		KeyEvent(const BMessage* keyMsg, BList* outlist
314									, void** setAsyncData,
315									BMessage* lastMouseMove);
316
317	virtual status_t			Archive(BMessage* into, bool deep = true)
318									const;
319	static BArchivable*			Instantiate(BMessage* from);
320};
321
322
323// Actuator for moving a mouse relative to its current position
324_EXPORT class MoveMouseByCommandActuator;
325class MoveMouseByCommandActuator : public MoveMouseCommandActuator {
326public:
327									MoveMouseByCommandActuator(int32 argc,
328										char** argv);
329									MoveMouseByCommandActuator(BMessage* from);
330									~MoveMouseByCommandActuator();
331
332	virtual filter_result 			KeyEvent(const BMessage* keyMsg,
333										BList* outlist, void** setAsyncData,
334										BMessage* lastMouseMove);
335	virtual status_t 				Archive(BMessage * into, bool deep = true)
336										const;
337	static 	BArchivable*			Instantiate(BMessage * from);
338};
339
340
341// Actuator to send BMessage to an application - written by Daniel Wesslen
342_EXPORT class SendMessageCommandActuator;
343class SendMessageCommandActuator : public CommandActuator {
344public:
345									SendMessageCommandActuator(int32 argc,
346										char** argv);
347									SendMessageCommandActuator(BMessage* from);
348									~SendMessageCommandActuator();
349
350	virtual filter_result			KeyEvent(const BMessage* keyMsg,
351										BList* outlist, void** setAsyncData,
352										BMessage* lastMouseMove);
353	virtual void					KeyEventAsync(const BMessage* keyUpMsg,
354										void* asyncData);
355	virtual status_t				Archive(BMessage* into, bool deep = true)
356										const;
357	static 	BArchivable*			Instantiate(BMessage * from);
358
359private:
360			void					_ParseFloatArgs(float* outArgs, int maxArgs
361										, const char* str) const;
362
363			BString					fSignature;
364			BMessage				fSendMsg;
365};
366
367#ifndef __HAIKU__
368#ifndef __INTEL__
369#pragma export reset
370#endif
371#endif
372
373#endif
374