workbench/tools/commodities/ClickToFront.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     ClickToFront commodity -- puts windows to front when clicked in.
   6 */
   7
   8 /******************************************************************************
   9
  10     NAME
  11
  12         ClickToFront
  13
  14     SYNOPSIS
  15
  16         CX_PRIORITY/N/K, QUALIFIER/K, DOUBLE/S
  17
  18     LOCATION
  19
  20         Workbench:Tools/Commodities
  21
  22     FUNCTION
  23
  24         Automatically raises and activates a window when clicking in it.
  25
  26     INPUTS
  27
  28         CX_PRIORITY  --  The priority of the commodity
  29
  30         QUALIFIER    --  Qualifier to match the double click (LEFT_ALT,
  31                          RIGHT_ALT, CTRL or NONE).
  32
  33         DOUBLE       --  If specified, clicking means double-clicking.
  34
  35     RESULT
  36
  37     NOTES
  38
  39     EXAMPLE
  40
  41     BUGS
  42
  43     SEE ALSO
  44
  45     INTERNALS
  46
  47 ******************************************************************************/
  48
  49 #include <aros/symbolsets.h>
  50 #include <intuition/intuition.h>
  51 #include <intuition/intuitionbase.h>
  52 #include <libraries/commodities.h>
  53 #include <libraries/locale.h>
  54 #include <proto/exec.h>
  55 #include <proto/dos.h>
  56 #include <proto/intuition.h>
  57 #include <proto/layers.h>
  58 #include <proto/commodities.h>
  59 #include <proto/input.h>
  60 #include <proto/alib.h>
  61 #include <proto/locale.h>
  62
  63 #include <stdio.h>
  64 #include <string.h>
  65
  66 #define  DEBUG 0
  67 #include <aros/debug.h>
  68
  69 #define CATCOMP_ARRAY
  70 #include "strings.h"
  71
  72 #define CATALOG_NAME     "System/Tools/Commodities.catalog"
  73 #define CATALOG_VERSION  2
  74
  75
  76 /***************************************************************************/
  77
  78 UBYTE version[] = "$VER: ClickToFront 0.3 (15.04.2006)";
  79
  80 #define ARG_TEMPLATE "CX_PRIORITY=PRI/N/K,QUALIFIER/K,DOUBLE/S"
  81
  82 #define  ARG_PRI        0
  83 #define  ARG_QUALIFIER  1
  84 #define  ARG_DOUBLE     2
  85 #define  NUM_ARGS       3
  86
  87 struct Device         *InputBase = NULL;
  88 struct Catalog        *catalog;
  89 struct IOStdReq       *inputIO;
  90
  91
  92 /* The ClickToFront broker */
  93 static struct NewBroker nb =
  94 {
  95     NB_VERSION,
  96     NULL,
  97     NULL,
  98     NULL,
  99     NBU_NOTIFY | NBU_UNIQUE,
 100     0,
 101     0,
 102     NULL,
 103     0
 104 };
 105
 106
 107 typedef struct _CFState
 108 {
 109     CxObj          *cs_broker;
 110     struct MsgPort *cs_msgPort;
 111 } CFState;
 112
 113
 114 typedef struct CF
 115 {
 116     struct Window *ci_thisWindow;
 117     struct Window *ci_lastWindow;
 118     UWORD          ci_qualifiers;       /* Qualifiers that must match */
 119     BOOL           ci_mouseHasMoved;
 120     BOOL           ci_doubleClick;
 121     ULONG          ci_lcSeconds;        /* Time stamp for the last click */
 122     ULONG          ci_lcMicros;
 123 } CF;
 124
 125
 126 static CF cfInfo =
 127 {
 128     NULL,
 129     NULL,
 130     0,
 131     FALSE,
 132     FALSE,
 133     0,
 134     0
 135 };
 136
 137 /************************************************************************************/
 138
 139 static void freeResources(CFState *cs);
 140 static BOOL initiate(int argc, char **argv, CFState *cs);
 141 static void getQualifier(STRPTR qualString);
 142 static void clicktoFront(CxMsg *msg, CxObj *co);
 143 static CONST_STRPTR _(ULONG id);
 144 static BOOL Locale_Initialize(VOID);
 145 static VOID Locale_Deinitialize(VOID);
 146 static void showSimpleMessage(CONST_STRPTR msgString);
 147
 148 /************************************************************************************/
 149
 150 static CONST_STRPTR _(ULONG id)
 151 {
 152     if (LocaleBase != NULL && catalog != NULL)
 153     {
 154         return GetCatalogStr(catalog, id, CatCompArray[id].cca_Str);
 155     }
 156     else
 157     {
 158         return CatCompArray[id].cca_Str;
 159     }
 160 }
 161
 162 /************************************************************************************/
 163
 164 static BOOL Locale_Initialize(VOID)
 165 {
 166     if (LocaleBase != NULL)
 167     {
 168         catalog = OpenCatalog
 169             (
 170              NULL, CATALOG_NAME, OC_Version, CATALOG_VERSION, TAG_DONE
 171             );
 172     }
 173     else
 174     {
 175         catalog = NULL;
 176     }
 177
 178     return TRUE;
 179 }
 180
 181 /************************************************************************************/
 182
 183 static VOID Locale_Deinitialize(VOID)
 184 {
 185     if(LocaleBase != NULL && catalog != NULL) CloseCatalog(catalog);
 186 }
 187
 188 /************************************************************************************/
 189
 190 static void showSimpleMessage(CONST_STRPTR msgString)
 191 {
 192     struct EasyStruct easyStruct;
 193
 194     easyStruct.es_StructSize    = sizeof(easyStruct);
 195     easyStruct.es_Flags         = 0;
 196     easyStruct.es_Title         = _(MSG_CLICK2FNT_CXNAME);
 197     easyStruct.es_TextFormat    = msgString;
 198     easyStruct.es_GadgetFormat  = _(MSG_OK);
 199
 200     if (IntuitionBase != NULL && !Cli() )
 201     {
 202         EasyRequestArgs(NULL, &easyStruct, NULL, NULL);
 203     }
 204     else
 205     {
 206         PutStr(msgString);
 207     }
 208 }
 209
 210 /************************************************************************************/
 211
 212 static BOOL initiate(int argc, char **argv, CFState *cs)
 213 {
 214     CxObj *customObj;
 215
 216     memset(cs, 0, sizeof(CFState));
 217
 218     if (Cli() != NULL)
 219     {
 220         struct RDArgs *rda;
 221         IPTR           args[] = { (IPTR) NULL, (IPTR) NULL, FALSE };
 222
 223         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 224
 225         if (rda != NULL)
 226         {
 227             if (args[ARG_PRI] != (IPTR) NULL)
 228             {
 229                 nb.nb_Pri = *(LONG *)args[ARG_PRI];
 230             }
 231
 232             getQualifier((STRPTR)args[ARG_QUALIFIER]);
 233
 234             cfInfo.ci_doubleClick = args[ARG_DOUBLE];
 235
 236             if (cfInfo.ci_doubleClick)
 237             {
 238                 D(bug("Using the double clicking method.\n"));
 239             }
 240         }
 241
 242         FreeArgs(rda);
 243     }
 244     else
 245     {
 246         UBYTE  **array = ArgArrayInit(argc, (UBYTE **)argv);
 247
 248         nb.nb_Pri = ArgInt(array, "CX_PRIORITY", 0);
 249         cfInfo.ci_doubleClick = ArgString(array, "DOUBLE", NULL) != NULL;
 250
 251         getQualifier(ArgString(array, "QUALIFIER", NULL));
 252
 253         ArgArrayDone();
 254     }
 255
 256     nb.nb_Name = _(MSG_CLICK2FNT_CXNAME);
 257     nb.nb_Title = _(MSG_CLICK2FNT_CXTITLE);
 258     nb.nb_Descr = _(MSG_CLICK2FNT_CXDESCR);
 259
 260     cs->cs_msgPort = CreateMsgPort();
 261
 262     if (cs->cs_msgPort == NULL)
 263     {
 264         showSimpleMessage(_(MSG_CANT_CREATE_MSGPORT));
 265
 266         return FALSE;
 267     }
 268
 269     nb.nb_Port = cs->cs_msgPort;
 270
 271     cs->cs_broker = CxBroker(&nb, 0);
 272
 273     if (cs->cs_broker == NULL)
 274     {
 275         return FALSE;
 276     }
 277
 278     customObj = CxCustom(clicktoFront, 0);
 279
 280     if (customObj == NULL)
 281     {
 282         showSimpleMessage(_(MSG_CANT_CREATE_MSGPORT));
 283
 284         return FALSE;
 285     }
 286
 287     AttachCxObj(cs->cs_broker, customObj);
 288     ActivateCxObj(cs->cs_broker, TRUE);
 289
 290     cfInfo.ci_thisWindow = IntuitionBase->ActiveWindow;
 291
 292     inputIO = (struct IOStdReq *)CreateIORequest(cs->cs_msgPort,
 293             sizeof(struct IOStdReq));
 294
 295     if (inputIO == NULL)
 296     {
 297         showSimpleMessage(_(MSG_CANT_ALLOCATE_MEM));
 298
 299         return FALSE;
 300     }
 301
 302     if ((OpenDevice("input.device", 0, (struct IORequest *)inputIO, 0)) != 0)
 303     {
 304         showSimpleMessage(_(MSG_CANT_OPEN_INPUTDEVICE));
 305
 306         return FALSE;
 307     }
 308
 309     InputBase = (struct Device *)inputIO->io_Device;
 310
 311     return TRUE;
 312 }
 313
 314 /************************************************************************************/
 315
 316 static void getQualifier(STRPTR qualString)
 317 {
 318     if (qualString == NULL)
 319     {
 320         return;
 321     }
 322
 323     if (strcmp("CTRL", qualString) == 0)
 324     {
 325         cfInfo.ci_qualifiers = IEQUALIFIER_CONTROL;
 326     }
 327
 328     if (strcmp("LEFT_ALT", qualString) == 0)
 329     {
 330         cfInfo.ci_qualifiers = IEQUALIFIER_LALT;
 331     }
 332
 333     if (strcmp("RIGHT_ALT", qualString) == 0)
 334     {
 335         cfInfo.ci_qualifiers = IEQUALIFIER_RALT;
 336     }
 337
 338     /* Default is NONE */
 339 }
 340
 341 /************************************************************************************/
 342
 343 static void freeResources(CFState *cs)
 344 {
 345     struct Message *cxm;
 346
 347     if (cs->cs_broker != NULL)
 348     {
 349         DeleteCxObjAll(cs->cs_broker);
 350     }
 351
 352     if (cs->cs_msgPort != NULL)
 353     {
 354         while ((cxm = GetMsg(cs->cs_msgPort)))
 355         {
 356             ReplyMsg(cxm);
 357         }
 358
 359         DeleteMsgPort(cs->cs_msgPort);
 360     }
 361
 362     if (inputIO != NULL)
 363     {
 364         CloseDevice((struct IORequest *)inputIO);
 365         DeleteIORequest((struct IORequest *)inputIO);
 366     }
 367 }
 368
 369 /************************************************************************************/
 370
 371 /* Currently we use single click, not double click... */
 372 static void clicktoFront(CxMsg *cxm, CxObj *co)
 373 {
 374     /* NOTE! Should use arbitration for IntuitionBase... */
 375
 376     struct InputEvent *ie = (struct InputEvent *)CxMsgData(cxm);
 377
 378     if (ie->ie_Class == IECLASS_RAWMOUSE)
 379     {
 380         if (ie->ie_Code == SELECTDOWN)
 381         {
 382             struct Screen *screen;
 383             struct Layer  *layer;
 384
 385             /* Mask relvant qualifiers (key qualifiers) */
 386             if ((PeekQualifier() & 0xff) != cfInfo.ci_qualifiers)
 387             {
 388                 D(bug("Qualifiers: %i, Wanted qualifiers: %i\n",
 389                             (int)PeekQualifier(),
 390                             (int)cfInfo.ci_qualifiers | IEQUALIFIER_LEFTBUTTON));
 391
 392                 return;
 393             }
 394
 395             cfInfo.ci_lastWindow = cfInfo.ci_thisWindow;
 396
 397             if (IntuitionBase->ActiveWindow != NULL)
 398             {
 399                 screen = IntuitionBase->ActiveWindow->WScreen;
 400             }
 401             else
 402             {
 403                 screen = IntuitionBase->ActiveScreen;
 404             }
 405
 406             layer = WhichLayer(&screen->LayerInfo,
 407                     screen->MouseX, screen->MouseY);
 408
 409             if (layer == NULL)
 410             {
 411                 return;
 412             }
 413
 414             cfInfo.ci_thisWindow = (layer != NULL) ?
 415                 (struct Window *)layer->Window : NULL;
 416
 417             /* Error: IB->ActiveWindow is non-NULL even if there is no
 418                active window! */
 419             if (layer->front != NULL)
 420             {
 421                 if (cfInfo.ci_doubleClick)
 422                 {
 423                     if (!DoubleClick(cfInfo.ci_lcSeconds, cfInfo.ci_lcMicros,
 424                                 ie->ie_TimeStamp.tv_secs,
 425                                 ie->ie_TimeStamp.tv_micro))
 426                     {
 427                         cfInfo.ci_lcSeconds = ie->ie_TimeStamp.tv_secs;
 428                         cfInfo.ci_lcMicros  = ie->ie_TimeStamp.tv_micro;
 429
 430                         return;
 431                     }
 432
 433                     D(bug("Time %i %i, last time %i %i\n",
 434                                 ie->ie_TimeStamp.tv_secs,
 435                                 ie->ie_TimeStamp.tv_micro,
 436                                 cfInfo.ci_lcSeconds,
 437                                 cfInfo.ci_lcMicros));
 438
 439                     cfInfo.ci_lcSeconds = ie->ie_TimeStamp.tv_secs;
 440                     cfInfo.ci_lcMicros  = ie->ie_TimeStamp.tv_micro;
 441
 442                     /* Both clicks better have been in the same window */
 443                     if (cfInfo.ci_lastWindow != cfInfo.ci_thisWindow)
 444                     {
 445                         return;
 446                     }
 447                 }
 448
 449                 WindowToFront(cfInfo.ci_thisWindow);
 450
 451                 if (cfInfo.ci_thisWindow != IntuitionBase->ActiveWindow)
 452                 {
 453                     ActivateWindow(cfInfo.ci_thisWindow);
 454                 }
 455
 456                 //DisposeCxMsg(cxm);
 457
 458                 D(bug("Put window %s to front.\n",
 459                             cfInfo.ci_thisWindow->Title));
 460             }
 461             else
 462             {
 463                 D(bug("New: %p Old: %p\n", cfInfo.ci_thisWindow,
 464                             IntuitionBase->ActiveWindow));
 465             }
 466         }
 467     }
 468 }
 469
 470 /************************************************************************************/
 471
 472 static void handleCx(CFState *cs)
 473 {
 474     CxMsg *msg;
 475     BOOL   quit = FALSE;
 476     LONG   signals;
 477
 478     while (!quit)
 479     {
 480         signals = Wait((1 << nb.nb_Port->mp_SigBit)  | SIGBREAKF_CTRL_C);
 481
 482         if (signals & (1 << nb.nb_Port->mp_SigBit))
 483         {
 484             while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort)))
 485             {
 486                 switch (CxMsgType(msg))
 487                 {
 488                     case CXM_COMMAND:
 489                         switch (CxMsgID(msg))
 490                         {
 491                             case CXCMD_DISABLE:
 492                                 ActivateCxObj(cs->cs_broker, FALSE);
 493                                 break;
 494
 495                             case CXCMD_ENABLE:
 496                                 ActivateCxObj(cs->cs_broker, TRUE);
 497                                 break;
 498
 499                             case CXCMD_UNIQUE:
 500                                 /* Running the program twice is the same as shutting
 501                                    down the existing program... */
 502                                 /* Fall through */
 503
 504                             case CXCMD_KILL:
 505                                 quit = TRUE;
 506                                 break;
 507
 508                         } /* switch (CxMsgID(msg)) */
 509                         break;
 510                 } /* switch (CxMsgType(msg))*/
 511
 512                 ReplyMsg((struct Message *)msg);
 513
 514             } /* while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort))) */
 515         }
 516
 517         if (signals & SIGBREAKF_CTRL_C)
 518         {
 519             quit = TRUE;
 520         }
 521
 522     } /* while(!quit) */
 523 }
 524
 525 /************************************************************************************/
 526
 527 int main(int argc, char **argv)
 528 {
 529     CFState cState;
 530     int     error = RETURN_OK;
 531
 532     if (initiate(argc, argv, &cState))
 533     {
 534         handleCx(&cState);
 535     }
 536     else
 537     {
 538         error = RETURN_FAIL;
 539     }
 540
 541     freeResources(&cState);
 542
 543     return error;
 544 }
 545
 546 /************************************************************************************/
 547
 548 ADD2INIT(Locale_Initialize,   90);
 549 ADD2EXIT(Locale_Deinitialize, 90);
 550