workbench/tools/commodities/ClickToFront.c

   1 /*
   2     Copyright © 1995-2013, 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 relevant 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             LockLayerInfo(&screen->LayerInfo);
 414             layer = WhichLayer(&screen->LayerInfo,
 415                                        screen->MouseX,
 416                                    screen->MouseY);
 417             UnlockLayerInfo(&screen->LayerInfo);
 418
 419             if (layer == NULL)
 420             {
 421                 return;
 422             }
 423
 424             cfInfo.ci_thisWindow = (layer != NULL) ?
 425                 (struct Window *)layer->Window : NULL;
 426
 427             /*
 428                Error: IB->ActiveWindow is non-NULL even if there is no
 429                active window!
 430             */
 431             if (layer->front != NULL)
 432             {
 433                 /*
 434                    Counting clicks is only meaningful if cfInfo.ci_clicksToDo
 435                    is no less than 2
 436                 */
 437                 if (cfInfo.ci_clicksToDo > 1)
 438                         {
 439                     cfInfo.ci_clicksDone++;
 440
 441                     D(bug("clicksDone = %i\n",cfInfo.ci_clicksDone));
 442
 443                     /*
 444                        Return if the delay between two clicks is longer than
 445                        Input-Preferences-set double-click delay
 446                     */
 447                     if (!DoubleClick(cfInfo.ci_lcSeconds,
 448                                       cfInfo.ci_lcMicros,
 449                                 ie->ie_TimeStamp.tv_secs,
 450                                ie->ie_TimeStamp.tv_micro))
 451                             {
 452                         cfInfo.ci_lcSeconds = ie->ie_TimeStamp.tv_secs;
 453                         cfInfo.ci_lcMicros  = ie->ie_TimeStamp.tv_micro;
 454                         cfInfo.ci_clicksDone = 1L;
 455                         D(bug("DoubleClick is FALSE\nclicksDone = %i\n",
 456                                                   cfInfo.ci_clicksDone));
 457                         return;
 458                             }
 459
 460                     D(bug("DoubleClick is TRUE\n"));
 461
 462                             D(bug("Time %i %i, last time %i %i\n",
 463                                         ie->ie_TimeStamp.tv_secs,
 464                                         ie->ie_TimeStamp.tv_micro,
 465                                         cfInfo.ci_lcSeconds,
 466                                         cfInfo.ci_lcMicros));
 467
 468                     cfInfo.ci_lcSeconds = ie->ie_TimeStamp.tv_secs;
 469                     cfInfo.ci_lcMicros  = ie->ie_TimeStamp.tv_micro;
 470
 471                     /* Return if the user didn't make enough clicks */
 472                     if (cfInfo.ci_clicksDone < cfInfo.ci_clicksToDo)
 473                     {
 474                         return;
 475                     }
 476
 477                             /* Return if the clicks weren't made in the same window */
 478                             if (cfInfo.ci_lastWindow != cfInfo.ci_thisWindow)
 479                             {
 480                         cfInfo.ci_clicksDone = 1L;
 481                         D(bug("Window changed. clicksDone = %i\n",
 482                                             cfInfo.ci_clicksDone));
 483                         return;
 484                             }
 485
 486                     /*
 487                        If we didn't return yet, that means that all conditions
 488                        are good to bring the window to front, and it will be
 489                        done now. We just reset cfInfo.ci_clicksDone to 0 in
 490                        order to be ready for another bring-to-front loop...
 491                     */
 492                     cfInfo.ci_clicksDone = 0L;
 493
 494                 }/* if (cfInfo.ci_nbClicks) */
 495
 496                 WindowToFront(cfInfo.ci_thisWindow);
 497
 498                 if (cfInfo.ci_thisWindow != IntuitionBase->ActiveWindow)
 499                 {
 500                     ActivateWindow(cfInfo.ci_thisWindow);
 501                 }
 502
 503                         D(bug("Window %s was put to front.\n",
 504                                      cfInfo.ci_thisWindow->Title));
 505             }
 506             else
 507             {
 508                         D(bug("New: %p Old: %p\n", cfInfo.ci_thisWindow,
 509                                    IntuitionBase->ActiveWindow));
 510             }
 511         } /* if (ie->ie_Code == SELECTDOWN) */
 512     } /* if (ie->ie_Class == IECLASS_RAWMOUSE) */
 513 }
 514
 515 /************************************************************************************/
 516
 517 static void handleCx(CFState *cs)
 518 {
 519     CxMsg *msg;
 520     BOOL   quit = FALSE;
 521     LONG   signals;
 522
 523     while (!quit)
 524     {
 525         signals = Wait((1 << nb.nb_Port->mp_SigBit)  | SIGBREAKF_CTRL_C);
 526
 527         if (signals & (1 << nb.nb_Port->mp_SigBit))
 528         {
 529             while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort)))
 530             {
 531                 switch (CxMsgType(msg))
 532                 {
 533                     case CXM_COMMAND:
 534                         switch (CxMsgID(msg))
 535                         {
 536                             case CXCMD_DISABLE:
 537                                 ActivateCxObj(cs->cs_broker, FALSE);
 538                                 break;
 539
 540                             case CXCMD_ENABLE:
 541                                 ActivateCxObj(cs->cs_broker, TRUE);
 542                                 break;
 543
 544                             case CXCMD_UNIQUE:
 545                                 /* Running the program twice is the same as shutting
 546                                    down the existing program... */
 547                                 /* Fall through */
 548
 549                             case CXCMD_KILL:
 550                                 quit = TRUE;
 551                                 break;
 552
 553                         } /* switch (CxMsgID(msg)) */
 554                         break;
 555                 } /* switch (CxMsgType(msg))*/
 556
 557                 ReplyMsg((struct Message *)msg);
 558
 559             } /* while ((msg = (CxMsg *)GetMsg(cs->cs_msgPort))) */
 560         }
 561
 562         if (signals & SIGBREAKF_CTRL_C)
 563         {
 564             quit = TRUE;
 565         }
 566
 567     } /* while(!quit) */
 568 }
 569
 570 /************************************************************************************/
 571
 572 int main(int argc, char **argv)
 573 {
 574     CFState cState;
 575     int      error = RETURN_OK;
 576
 577     D((argc == 0) ? bug("argc == 0\n") : bug("argc != 0\n") );
 578
 579     if (initiate(argc, argv, &cState))
 580     {
 581         handleCx(&cState);
 582     }
 583     else
 584     {
 585         error = RETURN_FAIL;
 586     }
 587
 588     freeResources(&cState);
 589
 590     return error;
 591 }
 592
 593 /************************************************************************************/
 594
 595 ADD2INIT(Locale_Initialize,   90);
 596 ADD2EXIT(Locale_Deinitialize, 90);
 597