workbench/tools/commodities/Opaque.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/symbolsets.h>
   7 #include <workbench/startup.h>
   8 #include <intuition/intuition.h>
   9 #include <intuition/intuitionbase.h>
  10 #include <graphics/gfx.h>
  11 #include <graphics/gfxbase.h>
  12 #include <libraries/commodities.h>
  13 #include <libraries/locale.h>
  14 #include <proto/exec.h>
  15 #include <proto/dos.h>
  16 #include <proto/intuition.h>
  17 #include <proto/layers.h>
  18 #include <proto/commodities.h>
  19 #include <proto/locale.h>
  20 #include <proto/alib.h>
  21 #include <proto/iffparse.h>
  22 #include <proto/icon.h>
  23 #include <prefs/prefhdr.h>
  24 #include <prefs/icontrol.h>
  25
  26 #define  DEBUG 0
  27 #include <aros/debug.h>
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #define CATCOMP_ARRAY
  33 #include "strings.h"
  34
  35 #define CATALOG_NAME     "System/Tools/Commodities.catalog"
  36 #define CATALOG_VERSION  2
  37
  38
  39 #define ACCELERATOR_THRESH      2
  40 #define ACCELERATOR_MULTI       2
  41
  42 /************************************************************************************/
  43
  44 /* Using ChangeWindowBox has the advantage, that one can specify absolute window
  45    coords, instead of relative ones as in case of MoveWindow. OTOH it has the
  46    disadvantage that it also generates IDCMP_NEWSIZE IntuiMessages. */
  47
  48 #define USE_CHANGEWINDOWBOX 0
  49
  50 #define CALL_WINDOWFUNCS_IN_INPUTHANDLER 0
  51
  52 /************************************************************************************/
  53
  54 UBYTE version[] = "$VER: Opaque 0.5 (15.04.2006)";
  55
  56 #define ARG_TEMPLATE "CX_PRIORITY=PRI/N/K"
  57
  58 #define ARG_PRI   0
  59 #define NUM_ARGS  1
  60
  61 #define ACTIONTYPE_DRAGGING 1
  62 #define ACTIONTYPE_RESIZING 2
  63
  64 #define SYSGADTYPE(gad) ((gad)->GadgetType & GTYP_SYSTYPEMASK)
  65
  66
  67 static struct NewBroker nb =
  68 {
  69    NB_VERSION,
  70    NULL,
  71    NULL,
  72    NULL,
  73    NBU_NOTIFY | NBU_UNIQUE,
  74    0,
  75    -120,
  76    NULL,
  77    0
  78 };
  79
  80 static struct Catalog *catalog;
  81 static struct MsgPort *cxport;
  82 static struct Window *actionwin;
  83 static struct Task *maintask;
  84
  85 static struct RDArgs *myargs;
  86 static CxObj *cxbroker, *cxcust;
  87 static ULONG cxmask, actionmask, icontrolmask;
  88 static WORD  winoffx, winoffy, winwidth, winheight;
  89 #if !USE_CHANGEWINDOWBOX
  90 static WORD actionstart_winx, actionstart_winy;
  91 #endif
  92 static struct Rectangle mousebounds;
  93 static LONG  gadgetLeft, gadgetTop;
  94 static LONG  gadgetWidth, gadgetHeight;
  95 static BYTE  actionsig, icontrolsig;
  96 static UBYTE actiontype;
  97 static BOOL quitme, disabled;
  98 static BOOL offScreenLayersFlag;
  99 static struct NotifyRequest *IControlChangeNR;
 100
 101 static IPTR args[NUM_ARGS];
 102 static char s[256];
 103
 104 static void HandleAction(void);
 105 static void HandleIControl(void);
 106
 107 /**********************************************************************************************/
 108
 109 #define ARRAY_TO_LONG(x) ( ((x)[0] << 24UL) + ((x)[1] << 16UL) + ((x)[2] << 8UL) + ((x)[3]) )
 110 #define ARRAY_TO_WORD(x) ( ((x)[0] << 8UL) + ((x)[1]) )
 111
 112 #define CONFIGNAME_ENV          "ENV:Sys/icontrol.prefs"
 113
 114 struct FileIControlPrefs
 115 {
 116     UBYTE   ic_Reserved0[4];
 117     UBYTE   ic_Reserved1[4];
 118     UBYTE   ic_Reserved2[4];
 119     UBYTE   ic_Reserved3[4];
 120     UBYTE   ic_TimeOut[2];
 121     UBYTE   ic_MetaDrag[2];
 122     UBYTE   ic_Flags[4];
 123     UBYTE   ic_WBtoFront;
 124     UBYTE   ic_FrontToBack;
 125     UBYTE   ic_ReqTrue;
 126     UBYTE   ic_ReqFalse;
 127 };
 128 /************************************************************************************/
 129
 130 static CONST_STRPTR _(ULONG id)
 131 {
 132     if (LocaleBase != NULL && catalog != NULL)
 133     {
 134         return GetCatalogStr(catalog, id, CatCompArray[id].cca_Str);
 135     }
 136     else
 137     {
 138         return CatCompArray[id].cca_Str;
 139     }
 140 }
 141
 142 /************************************************************************************/
 143
 144 static BOOL Locale_Initialize(VOID)
 145 {
 146     if (LocaleBase != NULL)
 147     {
 148         catalog = OpenCatalog
 149             (
 150              NULL, CATALOG_NAME, OC_Version, CATALOG_VERSION, TAG_DONE
 151             );
 152     }
 153     else
 154     {
 155         catalog = NULL;
 156     }
 157
 158     return TRUE;
 159 }
 160
 161 /************************************************************************************/
 162
 163 static VOID Locale_Deinitialize(VOID)
 164 {
 165     if(LocaleBase != NULL && catalog != NULL) CloseCatalog(catalog);
 166 }
 167
 168 /************************************************************************************/
 169
 170 static void showSimpleMessage(CONST_STRPTR msgString)
 171 {
 172     struct EasyStruct easyStruct;
 173
 174     easyStruct.es_StructSize    = sizeof(easyStruct);
 175     easyStruct.es_Flags         = 0;
 176     easyStruct.es_Title         = _(MSG_OPAQUE_CXNAME);
 177     easyStruct.es_TextFormat    = msgString;
 178     easyStruct.es_GadgetFormat  = _(MSG_OK);
 179
 180     if (IntuitionBase != NULL && !Cli() )
 181     {
 182         EasyRequestArgs(NULL, &easyStruct, NULL, NULL);
 183     }
 184     else
 185     {
 186         PutStr(msgString);
 187     }
 188 }
 189
 190 /************************************************************************************/
 191
 192 #define MINWINDOWWIDTH (5)
 193 #define MINWINDOWHEIGHT (5)
 194
 195 #define mouseLeft    mousebounds.MinX
 196 #define mouseTop     mousebounds.MinY
 197 #define mouseRight   mousebounds.MaxX
 198 #define mouseBottom  mousebounds.MaxY
 199
 200 void SetMouseBounds(struct Window *win)
 201 {
 202     WORD minheight, minwidth, maxheight, maxwidth;
 203
 204     if (win) {
 205         if (actiontype == ACTIONTYPE_DRAGGING) {
 206             if (offScreenLayersFlag) {
 207                 mouseLeft = 0; /* as left as you want */
 208                 mouseTop = winoffy; /* keep the titlebar visible */
 209                 mouseRight = win->WScreen->Width; /* as far right as you want */
 210                 mouseBottom = win->WScreen->Height - (gadgetHeight - (winoffy + 1));
 211             }
 212             else { /* bounds such that the window never goes offscreen */
 213                 mouseLeft = winoffx;
 214                 mouseTop = winoffy;
 215                 mouseRight = (win->WScreen->Width - winwidth) + winoffx;
 216                 mouseBottom = (win->WScreen->Height - winheight) + winoffy;
 217             }
 218         }
 219         else {  /* actiontype == ACTIONTYPE_RESIZING) */
 220             /* force legal min/max values */
 221             minwidth = win->MinWidth;
 222             maxwidth = win->MaxWidth;
 223             minheight = win->MinHeight;
 224             maxheight = win->MaxHeight;
 225
 226             if (maxwidth <= 0) maxwidth = win->WScreen->Width;
 227             if (maxheight <= 0) maxheight = win->WScreen->Height;
 228
 229             if ((minwidth < MINWINDOWWIDTH) || (minheight < MINWINDOWHEIGHT) || /* if any dimention too small, or */
 230                     (minwidth > maxwidth) || (minheight > maxheight) || /* either min/max value pairs are inverted, or */
 231                     (minwidth > win->Width) || (minheight > win->Height) || /* the window is already smaller than minwidth/height, or */
 232                     (maxwidth < win->Width) || (maxheight < win->Height)) { /* the window is already bigger than maxwidth/height */
 233                 minwidth = MINWINDOWWIDTH; /* then put sane values in */
 234                 minheight = MINWINDOWHEIGHT;
 235                 maxwidth = win->WScreen->Width;
 236                 maxheight = win->WScreen->Height;
 237             }
 238
 239             /* set new mouse bounds */
 240             mouseLeft = win->LeftEdge + minwidth - (win->Width - winoffx);
 241             mouseTop = win->TopEdge + minheight - (win->Height - winoffy);
 242             mouseRight = (win->LeftEdge + maxwidth) - (win->Width - winoffx);
 243             mouseBottom = (win->TopEdge + maxheight) - (win->Height - winoffy);
 244             if ((win->WScreen->Width - (win->Width - winoffx)) < mouseRight)
 245                 mouseRight = (win->WScreen->Width - (win->Width - winoffx));
 246             if ((win->WScreen->Height - (win->Height - winoffy)) < mouseBottom)
 247                 mouseBottom = (win->WScreen->Height - (win->Height - winoffy));
 248         }
 249     }
 250 }
 251
 252 /************************************************************************************/
 253
 254 BOOL GetOFFSCREENLAYERSPref()
 255 {
 256     static struct FileIControlPrefs loadprefs;
 257     struct IFFHandle                *iff;
 258     BOOL                      retval = TRUE;
 259
 260     if ((iff = AllocIFF()))
 261     {
 262         if ((iff->iff_Stream = (IPTR)Open(CONFIGNAME_ENV, MODE_OLDFILE)))
 263         {
 264             InitIFFasDOS(iff);
 265
 266             if (!OpenIFF(iff, IFFF_READ))
 267             {
 268                 if (!StopChunk(iff, ID_PREF, ID_ICTL))
 269                 {
 270                     if (!ParseIFF(iff, IFFPARSE_SCAN))
 271                     {
 272                         struct ContextNode *cn;
 273
 274                         cn = CurrentChunk(iff);
 275
 276                         if (cn->cn_Size == sizeof(loadprefs))
 277                         {
 278                             if (ReadChunkBytes(iff, &loadprefs, sizeof(loadprefs)) == sizeof(loadprefs))
 279                             {
 280                                 if ( ! (ARRAY_TO_LONG(loadprefs.ic_Flags) & ICF_OFFSCREENLAYERS) ) retval = FALSE;
 281                             }
 282                         }
 283
 284                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 285
 286                 } /* if (!StopChunk(iff, ID_PREF, ID_INPT)) */
 287
 288                 CloseIFF(iff);
 289
 290             } /* if (!OpenIFF(iff, IFFF_READ)) */
 291
 292             Close((BPTR)iff->iff_Stream);
 293
 294         } /* if ((iff->iff_Stream = (IPTR)Open(CONFIGNAME_ENV, MODE_OLDFILE))) */
 295
 296         FreeIFF(iff);
 297
 298     } /* if ((iff = AllocIFF())) */
 299
 300     return retval;
 301 }
 302
 303 /************************************************************************************/
 304
 305 static void Cleanup(CONST_STRPTR msg)
 306 {
 307     struct Message *cxmsg;
 308
 309     if (msg)
 310     {
 311         showSimpleMessage(msg);
 312     }
 313
 314     if(CxBase)
 315     {
 316         if (cxbroker) DeleteCxObjAll(cxbroker);
 317         if (cxport)
 318         {
 319             while((cxmsg = GetMsg(cxport)))
 320             {
 321                 ReplyMsg(cxmsg);
 322             }
 323
 324             DeleteMsgPort(cxport);
 325         }
 326     }
 327
 328     if (myargs) FreeArgs(myargs);
 329
 330     if (actionsig) FreeSignal(actionsig);
 331     if (icontrolsig) FreeSignal(icontrolsig);
 332
 333     if (IControlChangeNR != NULL) {
 334         EndNotify(IControlChangeNR);
 335         FreeMem(IControlChangeNR, sizeof(struct NotifyRequest));
 336     }
 337
 338     exit(0);
 339 }
 340
 341 /************************************************************************************/
 342
 343 static void DosError(void)
 344 {
 345     Fault(IoErr(),0,s,255);
 346     Cleanup(s);
 347 }
 348
 349 /************************************************************************************/
 350
 351 static void Init(void)
 352 {
 353
 354     /* create "action" signal, to handle window dragging and resize events */
 355     maintask = FindTask(0);
 356     if((actionsig = AllocSignal(-1L)) != -1)
 357     {
 358         actionmask = 1L << actionsig;
 359
 360         /* create "IControl pref changes" signal */
 361         if((icontrolsig = AllocSignal(-1L)) != -1)
 362         {
 363             icontrolmask = 1L << icontrolsig;
 364             if ((IControlChangeNR = AllocMem(sizeof(struct NotifyRequest), MEMF_CLEAR)))
 365             {
 366                 IControlChangeNR->nr_Name = CONFIGNAME_ENV;
 367                 IControlChangeNR->nr_Flags = NRF_SEND_SIGNAL;
 368                 IControlChangeNR->nr_stuff.nr_Signal.nr_Task = maintask;
 369                 IControlChangeNR->nr_stuff.nr_Signal.nr_SignalNum = icontrolsig;
 370
 371                 StartNotify(IControlChangeNR);
 372
 373                 /* set inital value for offscreenlayers */
 374                 offScreenLayersFlag = GetOFFSCREENLAYERSPref();
 375             } else {
 376                 showSimpleMessage(_(MSG_CANT_ALLOCATE_MEM));
 377             }
 378         }
 379     }
 380 }
 381
 382
 383 #define ABS(x) (((x)<0)?(-(x)):(x))
 384 inline WORD WITHACCEL(WORD raw) { if (ABS(raw) > ACCELERATOR_THRESH) return(raw << 2); else return(raw << 1);}
 385 inline WORD WITHOUTACCEL(WORD raw) { if (ABS(raw) > ACCELERATOR_THRESH) return(raw >> 2); else return(raw >> 1);}
 386
 387 /************************************************************************************/
 388
 389 static void GetArguments(int argc, char **argv)
 390 {
 391     if (argc == 0)
 392     {
 393         UBYTE **array = ArgArrayInit(argc, (UBYTE**)argv);
 394         nb.nb_Pri = ArgInt(array, "CX_PRIORITY", 0);
 395         ArgArrayDone();
 396     }
 397     else
 398     {
 399         if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
 400         {
 401             DosError();
 402         }
 403
 404         if (args[ARG_PRI]) nb.nb_Pri = *(LONG *)args[ARG_PRI];
 405     }
 406 }
 407
 408 /************************************************************************************/
 409
 410 static void OpaqueAction(CxMsg *msg,CxObj *obj)
 411 {
 412     static BOOL opaque_active = FALSE;
 413
 414     struct InputEvent *ie = (struct InputEvent *)CxMsgData(msg);
 415     struct Screen *scr;
 416
 417     if (ie->ie_Class == IECLASS_RAWMOUSE)
 418     {
 419         switch(ie->ie_Code)
 420         {
 421             case SELECTDOWN:
 422                 if (IntuitionBase->ActiveWindow)
 423                 {
 424                     scr = IntuitionBase->ActiveWindow->WScreen;
 425                 } else {
 426                     scr = IntuitionBase->ActiveScreen;
 427                 }
 428
 429                 if (!opaque_active && scr)
 430                 {
 431                     struct Layer *lay = WhichLayer(&scr->LayerInfo, scr->MouseX, scr->MouseY);
 432                     struct Window *win = NULL;
 433
 434                     if (lay) win = (struct Window *)lay->Window;
 435
 436                     if (win && !(ie->ie_Qualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND)))
 437                     {
 438                         struct Gadget *gad;
 439                         struct Window *newwin = NULL;
 440
 441                         for(gad = win->FirstGadget; gad; gad = gad->NextGadget)
 442                         {
 443                             /* FIXME: does not handle app made dragging/resize gadgets in
 444                                GZZ innerlayer or boopsi gadgets with special GM_HITTEST
 445                                method correctly! */
 446
 447                             if (!(gad->Flags & GFLG_DISABLED))
 448                             {
 449                                 WORD x = gad->LeftEdge;
 450                                 WORD y = gad->TopEdge;
 451                                 WORD w = gad->Width;
 452                                 WORD h = gad->Height;
 453                                 gadgetLeft = gad->LeftEdge;
 454                                 gadgetTop = gad->TopEdge;
 455                                 gadgetWidth = gad->Width;
 456                                 gadgetHeight = gad->Height;
 457
 458                                 if (gad->Flags & GFLG_RELRIGHT)  x += win->Width  - 1;
 459                                 if (gad->Flags & GFLG_RELBOTTOM) y += win->Height - 1;
 460                                 if (gad->Flags & GFLG_RELWIDTH)  w += win->Width;
 461                                 if (gad->Flags & GFLG_RELHEIGHT) h += win->Height;
 462
 463                                 if ((win->MouseX >= x) &&
 464                                         (win->MouseY >= y) &&
 465                                         (win->MouseX < x + w) &&
 466                                         (win->MouseY < y + h))
 467                                 {
 468                                     if ((SYSGADTYPE(gad) == GTYP_WDRAGGING) || (SYSGADTYPE(gad) == GTYP_SIZING))
 469                                     {
 470                                         /* found dragging or resize gadget */
 471                                         newwin = win;
 472                                         actiontype = (SYSGADTYPE(gad) == GTYP_WDRAGGING) ? ACTIONTYPE_DRAGGING :
 473                                             ACTIONTYPE_RESIZING;
 474                                     }
 475                                     break;
 476                                 }
 477                             }
 478
 479                         } /* for(gad = win->FirstGadget; gad; gad = gad->NextGadget) */
 480
 481                         win = newwin;
 482
 483                     } /* if (win && !(ie->ie_Qualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND))) */
 484
 485                     if (win)
 486                     {
 487                         opaque_active = TRUE;
 488                         if (IntuitionBase->ActiveWindow != win) ActivateWindow(win);
 489                         actionwin = win;
 490                         winoffx   = win->WScreen->MouseX - win->LeftEdge;
 491                         winoffy   = win->WScreen->MouseY - win->TopEdge;
 492                         winwidth  = win->Width;
 493                         winheight = win->Height;
 494 #if !USE_CHANGEWINDOWBOX
 495                         actionstart_winx = win->LeftEdge;
 496                         actionstart_winy = win->TopEdge;
 497 #endif
 498                         DisposeCxMsg(msg);
 499                         /* reset mouse bounds */
 500                         SetMouseBounds(actionwin);
 501                         if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 502
 503                         //Signal(maintask, icontrolmask);
 504                     }
 505
 506                 } /* if (!opaque_active && scr) */
 507                 break;
 508
 509             case SELECTUP:
 510                 if (opaque_active)
 511                 {
 512                     opaque_active = FALSE;
 513                     if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, NULL, 0, NULL);
 514                     DisposeCxMsg(msg);
 515                 }
 516                 break;
 517
 518             case IECODE_NOBUTTON:
 519                 if (opaque_active)
 520                 {
 521                     if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 522
 523 #if CALL_WINDOWFUNCS_IN_INPUTHANDLER
 524                     HandleAction();
 525 #else
 526                     Signal(maintask, actionmask);
 527 #endif
 528                 }
 529                 break;
 530
 531         } /* switch(ie->ie_Code) */
 532
 533     } /* if (ie->ie_Class == IECLASS_RAWMOUSE) */
 534     else if (ie->ie_Class == IECLASS_TIMER)
 535     {
 536         if (opaque_active && !offScreenLayersFlag)
 537         {
 538             SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 539         }
 540     }
 541 }
 542
 543 /************************************************************************************/
 544
 545 static void InitCX(void)
 546 {
 547     if (!(cxport = CreateMsgPort()))
 548     {
 549         Cleanup(_(MSG_CANT_CREATE_MSGPORT));
 550     }
 551
 552     nb.nb_Port = cxport;
 553
 554     cxmask = 1L << cxport->mp_SigBit;
 555
 556     if (!(cxbroker = CxBroker(&nb, 0)))
 557     {
 558         Cleanup(_(MSG_CANT_CREATE_BROKER));
 559     }
 560
 561     if (!(cxcust = CxCustom(OpaqueAction, 0)))
 562     {
 563         Cleanup(_(MSG_CANT_CREATE_CUSTOM));
 564     }
 565
 566     AttachCxObj(cxbroker, cxcust);
 567     ActivateCxObj(cxbroker, 1);
 568
 569 }
 570
 571 /************************************************************************************/
 572
 573 /* Handle the case where the IControl Prefs have changed */
 574 static void HandleIControl(void)
 575 {
 576     D(bug("[Opaque] notified of icontrol.prefs change\n"));
 577     offScreenLayersFlag = GetOFFSCREENLAYERSPref();
 578     //SetMouseBounds();
 579 }
 580
 581 /************************************************************************************/
 582
 583 /* Move window to absolute position newWindowX, newWindowY */
 584 static void HandleAction(void)
 585 {
 586     if (actiontype == ACTIONTYPE_DRAGGING)
 587     {
 588         WORD newx = actionwin->WScreen->MouseX - winoffx;
 589         WORD newy = actionwin->WScreen->MouseY - winoffy;
 590
 591         /* MoveWindow(actionwin, newx - actionwin->LeftEdge, newy - actionwin->TopEdge); */
 592 #if USE_CHANGEWINDOWBOX
 593         ChangeWindowBox(actionwin, newx, newy, actionwin->Width, actionwin->Height);
 594 #else
 595         MoveWindow(actionwin, newx - actionstart_winx, newy - actionstart_winy);
 596         actionstart_winx = newx;
 597         actionstart_winy = newy;
 598 #endif
 599     }
 600     else
 601     {
 602         LONG neww = winwidth  + actionwin->WScreen->MouseX - actionwin->LeftEdge - winoffx;
 603         LONG newh = winheight + actionwin->WScreen->MouseY - actionwin->TopEdge  - winoffy;
 604
 605         if ((neww != actionwin->Width) || (newh != actionwin->Height))
 606         {
 607             /* SizeWindow(actionwin, neww - actionwin->Width, newh - actionwin->Height); */
 608             ChangeWindowBox(actionwin, actionwin->LeftEdge, actionwin->TopEdge, neww, newh);
 609         }
 610     }
 611 }
 612
 613 /************************************************************************************/
 614
 615 static void HandleCx(void)
 616 {
 617     CxMsg *msg;
 618     while((msg = (CxMsg *)GetMsg(cxport)))
 619     {
 620         switch(CxMsgType(msg))
 621         {
 622             case CXM_COMMAND:
 623                 switch(CxMsgID(msg))
 624                 {
 625                     case CXCMD_DISABLE:
 626                         ActivateCxObj(cxbroker,0L);
 627                         disabled = TRUE;
 628                         break;
 629
 630                     case CXCMD_ENABLE:
 631                         ActivateCxObj(cxbroker,1L);
 632                         disabled = FALSE;
 633                         break;
 634
 635                     case CXCMD_UNIQUE:
 636                     case CXCMD_KILL:
 637                         quitme = TRUE;
 638                         break;
 639
 640                 } /* switch(CxMsgID(msg)) */
 641                 break;
 642
 643         } /* switch (CxMsgType(msg))*/
 644
 645         ReplyMsg((struct Message *)msg);
 646
 647     } /* while((msg = (CxMsg *)GetMsg(cxport))) */
 648 }
 649
 650 /************************************************************************************/
 651
 652 static void HandleAll(void)
 653 {
 654     ULONG sigs;
 655
 656     while(!quitme)
 657     {
 658         sigs = Wait(cxmask | actionmask | icontrolmask | SIGBREAKF_CTRL_C);
 659
 660         if (sigs & cxmask) HandleCx();
 661         if (sigs & actionmask) HandleAction(); /* "Action" == window moving or resizing */
 662         if (sigs & icontrolmask) HandleIControl();
 663         if (sigs & SIGBREAKF_CTRL_C) quitme = TRUE;
 664     } /* while(!quitme) */
 665 }
 666
 667 /************************************************************************************/
 668
 669 int main(int argc, char **argv)
 670 {
 671     Init();
 672
 673     nb.nb_Name = _(MSG_OPAQUE_CXNAME);
 674     nb.nb_Title = _(MSG_OPAQUE_CXTITLE);
 675     nb.nb_Descr = _(MSG_OPAQUE_CXDESCR);
 676
 677     GetArguments(argc, argv);
 678     InitCX();
 679     HandleAll();
 680     Cleanup(0);
 681     return 0;
 682 }
 683
 684 /************************************************************************************/
 685
 686 ADD2INIT(Locale_Initialize,   90);
 687 ADD2EXIT(Locale_Deinitialize, 90);
 688