workbench/tools/commodities/AltKeyQ.c

   1 /*
   2     Copyright © 2009-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     AltKeyQ -- Enter characters by their ANSI number.
   6 */
   7
   8 /******************************************************************************
   9
  10     NAME
  11
  12         AltKeyQ
  13
  14     SYNOPSIS
  15
  16         CX_PRIORITY/N/K
  17
  18     LOCATION
  19
  20         SYS:Tools/Commodities
  21
  22     FUNCTION
  23
  24         Enter characters by pressing the ALT key and ANSI number of
  25         the character. It's a clone of a Commodity which you can
  26         find under the same name in Aminet.
  27
  28     INPUTS
  29
  30         CX_PRIORITY  --  The priority of the commodity
  31
  32     RESULT
  33
  34     NOTES
  35
  36     EXAMPLE
  37
  38         <Alt> 1 2 0 inserts 'x' into the input stream.
  39
  40     BUGS
  41
  42         You can only enter characters which are defined
  43         in the keymap of your keyboard.
  44
  45     SEE ALSO
  46
  47     INTERNALS
  48
  49     HISTORY
  50
  51 ******************************************************************************/
  52
  53 #define DEBUG 0
  54 #include <aros/debug.h>
  55
  56 #include <aros/symbolsets.h>
  57 #include <devices/rawkeycodes.h>
  58
  59 #include <proto/exec.h>
  60 #include <proto/dos.h>
  61 #include <proto/locale.h>
  62 #include <proto/intuition.h>
  63 #include <proto/commodities.h>
  64 #include <proto/alib.h>
  65
  66 const char *verstag = "\0$VER: AltKeyQ 1.0 (23.05.2009) © The AROS Development Team";
  67
  68 #define ARG_TEMPLATE "CX_PRIORITY=PRI/N/K"
  69
  70 static struct NewBroker nb =
  71 {
  72     NB_VERSION,
  73     NULL,
  74     NULL,
  75     NULL,
  76     NBU_NOTIFY | NBU_UNIQUE,
  77     0,
  78     0,
  79     NULL,
  80     0
  81 };
  82
  83 struct AKQState
  84 {
  85     CxObj          *akq_broker;
  86     struct MsgPort *akq_msgPort;
  87 };
  88
  89 struct  /* structure with information to send: */
  90 {
  91     UBYTE value;        /*     ASCII value for the IEvent to send */
  92     UBYTE nul;          /*     ASCII NUL byte for InvertString() */
  93 } send;
  94
  95 enum {
  96     ARG_PRI,
  97     NUM_ARGS
  98 };
  99
 100 static struct Catalog *catalog;
 101 static struct Task *mainTask;
 102 static ULONG sendSigBit = -1;
 103
 104 #define CATCOMP_ARRAY
 105 #include "strings.h"
 106
 107 #define CATALOG_NAME     "System/Tools/Commodities.catalog"
 108 #define CATALOG_VERSION  3
 109
 110 /************************************************************************************/
 111
 112 static void collectKeysFunc(CxMsg *msg, CxObj *co);
 113 static void handleCx(struct AKQState *as);
 114 static void freeResources(struct AKQState *as);
 115 static BOOL initiate(int argc, char **argv, struct AKQState *as);
 116 static void showSimpleMessage(CONST_STRPTR msgString);
 117 static VOID Locale_Deinitialize(VOID);
 118 static BOOL Locale_Initialize(VOID);
 119 static CONST_STRPTR _(ULONG id);
 120
 121 /************************************************************************************/
 122
 123 static CONST_STRPTR _(ULONG id)
 124 {
 125     if (LocaleBase != NULL && catalog != NULL)
 126     {
 127         return GetCatalogStr(catalog, id, CatCompArray[id].cca_Str);
 128     }
 129     else
 130     {
 131         return CatCompArray[id].cca_Str;
 132     }
 133 }
 134
 135 /************************************************************************************/
 136
 137 static BOOL Locale_Initialize(VOID)
 138 {
 139     if (LocaleBase != NULL)
 140     {
 141         catalog = OpenCatalog(NULL, CATALOG_NAME, OC_Version, CATALOG_VERSION, TAG_DONE);
 142     }
 143     else
 144     {
 145         catalog = NULL;
 146     }
 147
 148     return TRUE;
 149 }
 150
 151 /************************************************************************************/
 152
 153 static VOID Locale_Deinitialize(VOID)
 154 {
 155     if(LocaleBase != NULL && catalog != NULL) CloseCatalog(catalog);
 156 }
 157
 158 /************************************************************************************/
 159
 160 static void showSimpleMessage(CONST_STRPTR msgString)
 161 {
 162     struct EasyStruct easyStruct;
 163
 164     easyStruct.es_StructSize    = sizeof(easyStruct);
 165     easyStruct.es_Flags         = 0;
 166     easyStruct.es_Title         = _(MSG_ALTKEYQ_CXNAME);
 167     easyStruct.es_TextFormat    = msgString;
 168     easyStruct.es_GadgetFormat  = _(MSG_OK);
 169
 170     if (IntuitionBase != NULL && !Cli() )
 171     {
 172         EasyRequestArgs(NULL, &easyStruct, NULL, NULL);
 173     }
 174     else
 175     {
 176         PutStr(msgString);
 177     }
 178 }
 179
 180 /************************************************************************************/
 181
 182 static BOOL initiate(int argc, char **argv, struct AKQState *as)
 183 {
 184     CxObj *customObj;
 185
 186     memset(as, 0, sizeof(struct AKQState));
 187
 188     if (Cli() != NULL)
 189     {
 190         struct RDArgs *rda;
 191         IPTR          *args[] = { NULL, (IPTR)FALSE };
 192
 193         rda = ReadArgs(ARG_TEMPLATE, (IPTR *)args, NULL);
 194
 195         if (rda != NULL)
 196         {
 197             if (args[ARG_PRI] != NULL)
 198             {
 199                 nb.nb_Pri = *args[ARG_PRI];
 200             }
 201         }
 202         FreeArgs(rda);
 203     }
 204     else
 205     {
 206         UBYTE **array = ArgArrayInit(argc, (UBYTE **)argv);
 207
 208         nb.nb_Pri = ArgInt(array, "CX_PRIORITY", 0);
 209
 210         ArgArrayDone();
 211     }
 212
 213     nb.nb_Name = _(MSG_ALTKEYQ_CXNAME);
 214     nb.nb_Title = _(MSG_ALTKEYQ_CXTITLE);
 215     nb.nb_Descr = _(MSG_ALTKEYQ_CXDESCR);
 216
 217     as->akq_msgPort = CreateMsgPort();
 218
 219     if (as->akq_msgPort == NULL)
 220     {
 221         showSimpleMessage(_(MSG_CANT_CREATE_MSGPORT));
 222         return FALSE;
 223     }
 224
 225     nb.nb_Port = as->akq_msgPort;
 226
 227     as->akq_broker = CxBroker(&nb, 0);
 228
 229     if (as->akq_broker == NULL)
 230     {
 231         return FALSE;
 232     }
 233
 234     customObj = CxCustom(collectKeysFunc, 0);
 235
 236     if (customObj == NULL)
 237     {
 238         showSimpleMessage(_(MSG_CANT_CREATE_CUSTOM));
 239         return FALSE;
 240     }
 241
 242     AttachCxObj(as->akq_broker, customObj);
 243     sendSigBit = AllocSignal(-1);
 244     if (sendSigBit == -1)
 245     {
 246         showSimpleMessage(_(MSG_CANT_ALLOCATE_SIGNAL));
 247         return FALSE;
 248     }
 249     mainTask = FindTask(NULL);
 250     ActivateCxObj(as->akq_broker, TRUE);
 251
 252     return TRUE;
 253 }
 254
 255 /************************************************************************************/
 256
 257 static void freeResources(struct AKQState *as)
 258 {
 259     struct Message  *cxm;
 260
 261     if (CxBase != NULL)
 262     {
 263         if (as->akq_broker != NULL)
 264         {
 265             DeleteCxObjAll(as->akq_broker);
 266         }
 267     }
 268
 269     if (as->akq_msgPort != NULL)
 270     {
 271         while ((cxm = GetMsg(as->akq_msgPort)))
 272         {
 273             ReplyMsg(cxm);
 274         }
 275
 276         DeleteMsgPort(as->akq_msgPort);
 277     }
 278
 279     FreeSignal(sendSigBit);
 280 }
 281
 282 /************************************************************************************/
 283
 284 static void collectKeysFunc(CxMsg *msg, CxObj *co)
 285 {
 286     /* Scancodes of numeric pad */
 287     static TEXT keys[]= "\x0f\x1d\x1e\x1f\x2d\x2e\x2f\x3d\x3e\x3f";
 288
 289     static BOOL collflag;
 290     static ULONG value;
 291     TEXT *s;
 292
 293     struct InputEvent *ie = (struct InputEvent *)CxMsgData(msg);
 294
 295     if (ie->ie_Class == IECLASS_RAWKEY)
 296     {
 297         if (ie->ie_Code == (RAWKEY_LALT | IECODE_UP_PREFIX))
 298         {
 299             if (collflag)
 300             {
 301                 /* User released left ALT key */
 302                 if (value < 256)
 303                 {
 304                     send.value = value;
 305                     D(bug("Value %u Character %c\n", send.value, send.value));
 306                     Signal(mainTask, 1 << sendSigBit);
 307                 }
 308                 else
 309                 {
 310                     D(bug("Value too large\n"));
 311                 }
 312
 313                 goto setinactive;
 314             }
 315         }
 316         else if (ie->ie_Qualifier & IEQUALIFIER_LALT)
 317         {
 318             if ((s= strchr(keys, ie->ie_Code)))
 319             {
 320                 /* collect value */
 321                 ie->ie_Code |= IECODE_UP_PREFIX;
 322                 value = value * 10 + (s - keys);
 323                 collflag = TRUE;
 324             }
 325         }
 326         else
 327 setinactive:
 328         {
 329             value = 0;
 330             collflag = FALSE;
 331         }
 332     }
 333 }
 334
 335 /************************************************************************************/
 336
 337 /* React on command messages sent by commodities.library */
 338 static void handleCx(struct AKQState *as)
 339 {
 340     CxMsg *msg;
 341     BOOL   quit = FALSE;
 342     LONG   signals;
 343
 344     while (!quit)
 345     {
 346         signals = Wait((1 << nb.nb_Port->mp_SigBit) | (1 << sendSigBit) | SIGBREAKF_CTRL_C);
 347
 348         if (signals & (1 << sendSigBit))
 349         {
 350             D(bug("signal received\n"));
 351             struct InputEvent *ie = InvertString((TEXT *)&send, NULL);
 352             if (ie)
 353             {
 354                 AddIEvents(ie);
 355                 FreeIEvents(ie);
 356             }
 357             else
 358             {
 359                 D(bug("No event added\n"));
 360             }
 361         }
 362
 363         if (signals & (1 << nb.nb_Port->mp_SigBit))
 364         {
 365             while ((msg = (CxMsg *)GetMsg(as->akq_msgPort)))
 366             {
 367                 switch (CxMsgType(msg))
 368                 {
 369                     case CXM_COMMAND:
 370                         switch (CxMsgID(msg))
 371                         {
 372                             case CXCMD_DISABLE:
 373                                 ActivateCxObj(as->akq_broker, FALSE);
 374                                 break;
 375
 376                             case CXCMD_ENABLE:
 377                                 ActivateCxObj(as->akq_broker, TRUE);
 378                                 break;
 379
 380                             case CXCMD_UNIQUE:
 381                                 /* Running the program twice <=> quit */
 382                                 /* Fall through */
 383
 384                             case CXCMD_KILL:
 385                                 quit = TRUE;
 386                                 break;
 387
 388                         } /* switch(CxMsgID(msg)) */
 389
 390                         break;
 391                 } /* switch (CxMsgType(msg))*/
 392
 393                 ReplyMsg((struct Message *)msg);
 394
 395             } /* while((msg = (CxMsg *)GetMsg(cs->cs_msgPort))) */
 396         }
 397
 398         if (signals & SIGBREAKF_CTRL_C)
 399         {
 400             quit = TRUE;
 401         }
 402
 403     } /* while (!quit) */
 404 }
 405
 406 /************************************************************************************/
 407
 408 int main(int argc, char **argv)
 409 {
 410     struct AKQState akqState;
 411     int     error = RETURN_OK;
 412
 413     if (initiate(argc, argv, &akqState))
 414     {
 415         handleCx(&akqState);
 416     }
 417     else
 418     {
 419         error = RETURN_FAIL;
 420     }
 421
 422     freeResources(&akqState);
 423
 424     return error;
 425 }
 426
 427 /************************************************************************************/
 428
 429 ADD2INIT(Locale_Initialize,   90);
 430 ADD2EXIT(Locale_Deinitialize, 90);
 431