workbench/tools/commodities/ClickToFront.c

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