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