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  3
  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.6 (25.5.2010)";
  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 dimension 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 = NULL;
 432                     struct Window *win = NULL;
 433
 434                     LockLayerInfo(&scr->LayerInfo);
 435                     lay = WhichLayer(&scr->LayerInfo, scr->MouseX, scr->MouseY);
 436                     UnlockLayerInfo(&scr->LayerInfo);
 437
 438                     if (lay) win = (struct Window *)lay->Window;
 439
 440                     if (win && !(ie->ie_Qualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND)))
 441                     {
 442                         struct Gadget *gad;
 443                         struct Window *newwin = NULL;
 444
 445                         for(gad = win->FirstGadget; gad; gad = gad->NextGadget)
 446                         {
 447                             /* FIXME: does not handle app made dragging/resize gadgets in
 448                                GZZ innerlayer or boopsi gadgets with special GM_HITTEST
 449                                method correctly! */
 450
 451                             if (!(gad->Flags & GFLG_DISABLED))
 452                             {
 453                                 WORD x = gad->LeftEdge;
 454                                 WORD y = gad->TopEdge;
 455                                 WORD w = gad->Width;
 456                                 WORD h = gad->Height;
 457                                 gadgetLeft = gad->LeftEdge;
 458                                 gadgetTop = gad->TopEdge;
 459                                 gadgetWidth = gad->Width;
 460                                 gadgetHeight = gad->Height;
 461
 462                                 if (gad->Flags & GFLG_RELRIGHT)  x += win->Width  - 1;
 463                                 if (gad->Flags & GFLG_RELBOTTOM) y += win->Height - 1;
 464                                 if (gad->Flags & GFLG_RELWIDTH)  w += win->Width;
 465                                 if (gad->Flags & GFLG_RELHEIGHT) h += win->Height;
 466
 467                                 if ((win->MouseX >= x) &&
 468                                         (win->MouseY >= y) &&
 469                                         (win->MouseX < x + w) &&
 470                                         (win->MouseY < y + h))
 471                                 {
 472                                     if ((SYSGADTYPE(gad) == GTYP_WDRAGGING) || (SYSGADTYPE(gad) == GTYP_SIZING))
 473                                     {
 474                                         /* found dragging or resize gadget */
 475                                         newwin = win;
 476                                         actiontype = (SYSGADTYPE(gad) == GTYP_WDRAGGING) ? ACTIONTYPE_DRAGGING :
 477                                             ACTIONTYPE_RESIZING;
 478                                     }
 479                                     break;
 480                                 }
 481                             }
 482
 483                         } /* for(gad = win->FirstGadget; gad; gad = gad->NextGadget) */
 484
 485                         win = newwin;
 486
 487                     } /* if (win && !(ie->ie_Qualifier & (IEQUALIFIER_LCOMMAND | IEQUALIFIER_RCOMMAND))) */
 488
 489                     if (win)
 490                     {
 491                         opaque_active = TRUE;
 492                         if (IntuitionBase->ActiveWindow != win) ActivateWindow(win);
 493                         actionwin = win;
 494                         winoffx   = win->WScreen->MouseX - win->LeftEdge;
 495                         winoffy   = win->WScreen->MouseY - win->TopEdge;
 496                         winwidth  = win->Width;
 497                         winheight = win->Height;
 498 #if !USE_CHANGEWINDOWBOX
 499                         actionstart_winx = win->LeftEdge;
 500                         actionstart_winy = win->TopEdge;
 501 #endif
 502                         DisposeCxMsg(msg);
 503                         /* reset mouse bounds */
 504                         SetMouseBounds(actionwin);
 505                         if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 506
 507                         //Signal(maintask, icontrolmask);
 508                     }
 509
 510                 } /* if (!opaque_active && scr) */
 511                 break;
 512
 513             case SELECTUP:
 514                 if (opaque_active)
 515                 {
 516                     opaque_active = FALSE;
 517                     if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, NULL, 0, NULL);
 518                     DisposeCxMsg(msg);
 519                 }
 520                 break;
 521
 522             case IECODE_NOBUTTON:
 523                 if (opaque_active)
 524                 {
 525                     if (!offScreenLayersFlag) SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 526
 527 #if CALL_WINDOWFUNCS_IN_INPUTHANDLER
 528                     HandleAction();
 529 #else
 530                     Signal(maintask, actionmask);
 531 #endif
 532                 }
 533                 break;
 534
 535         } /* switch(ie->ie_Code) */
 536
 537     } /* if (ie->ie_Class == IECLASS_RAWMOUSE) */
 538     else if (ie->ie_Class == IECLASS_TIMER)
 539     {
 540         if (opaque_active && !offScreenLayersFlag)
 541         {
 542             SetPointerBounds(actionwin->WScreen, &mousebounds, 0, NULL);
 543         }
 544     }
 545 }
 546
 547 /************************************************************************************/
 548
 549 static void InitCX(void)
 550 {
 551     if (!(cxport = CreateMsgPort()))
 552     {
 553         Cleanup(_(MSG_CANT_CREATE_MSGPORT));
 554     }
 555
 556     nb.nb_Port = cxport;
 557
 558     cxmask = 1L << cxport->mp_SigBit;
 559
 560     if (!(cxbroker = CxBroker(&nb, 0)))
 561     {
 562         //Cleanup(_(MSG_CANT_CREATE_BROKER));
 563         Cleanup(NULL); // TO DO: show error if commodity wasn't running
 564     }
 565
 566     if (!(cxcust = CxCustom(OpaqueAction, 0)))
 567     {
 568         Cleanup(_(MSG_CANT_CREATE_CUSTOM));
 569     }
 570
 571     AttachCxObj(cxbroker, cxcust);
 572     ActivateCxObj(cxbroker, 1);
 573
 574 }
 575
 576 /************************************************************************************/
 577
 578 /* Handle the case where the IControl Prefs have changed */
 579 static void HandleIControl(void)
 580 {
 581     D(bug("[Opaque] notified of icontrol.prefs change\n"));
 582     offScreenLayersFlag = GetOFFSCREENLAYERSPref();
 583     //SetMouseBounds();
 584 }
 585
 586 /************************************************************************************/
 587
 588 /* Move window to absolute position newWindowX, newWindowY */
 589 static void HandleAction(void)
 590 {
 591     if (actiontype == ACTIONTYPE_DRAGGING)
 592     {
 593         WORD newx = actionwin->WScreen->MouseX - winoffx;
 594         WORD newy = actionwin->WScreen->MouseY - winoffy;
 595
 596         /* MoveWindow(actionwin, newx - actionwin->LeftEdge, newy - actionwin->TopEdge); */
 597 #if USE_CHANGEWINDOWBOX
 598         ChangeWindowBox(actionwin, newx, newy, actionwin->Width, actionwin->Height);
 599 #else
 600         MoveWindow(actionwin, newx - actionstart_winx, newy - actionstart_winy);
 601         actionstart_winx = newx;
 602         actionstart_winy = newy;
 603 #endif
 604     }
 605     else
 606     {
 607         LONG neww = winwidth  + actionwin->WScreen->MouseX - actionwin->LeftEdge - winoffx;
 608         LONG newh = winheight + actionwin->WScreen->MouseY - actionwin->TopEdge  - winoffy;
 609
 610         if ((neww != actionwin->Width) || (newh != actionwin->Height))
 611         {
 612             /* SizeWindow(actionwin, neww - actionwin->Width, newh - actionwin->Height); */
 613             ChangeWindowBox(actionwin, actionwin->LeftEdge, actionwin->TopEdge, neww, newh);
 614         }
 615     }
 616 }
 617
 618 /************************************************************************************/
 619
 620 static void HandleCx(void)
 621 {
 622     CxMsg *msg;
 623     while((msg = (CxMsg *)GetMsg(cxport)))
 624     {
 625         switch(CxMsgType(msg))
 626         {
 627             case CXM_COMMAND:
 628                 switch(CxMsgID(msg))
 629                 {
 630                     case CXCMD_DISABLE:
 631                         ActivateCxObj(cxbroker,0L);
 632                         disabled = TRUE;
 633                         break;
 634
 635                     case CXCMD_ENABLE:
 636                         ActivateCxObj(cxbroker,1L);
 637                         disabled = FALSE;
 638                         break;
 639
 640                     case CXCMD_UNIQUE:
 641                     case CXCMD_KILL:
 642                         quitme = TRUE;
 643                         break;
 644
 645                 } /* switch(CxMsgID(msg)) */
 646                 break;
 647
 648         } /* switch (CxMsgType(msg))*/
 649
 650         ReplyMsg((struct Message *)msg);
 651
 652     } /* while((msg = (CxMsg *)GetMsg(cxport))) */
 653 }
 654
 655 /************************************************************************************/
 656
 657 static void HandleAll(void)
 658 {
 659     ULONG sigs;
 660
 661     while(!quitme)
 662     {
 663         sigs = Wait(cxmask | actionmask | icontrolmask | SIGBREAKF_CTRL_C);
 664
 665         if (sigs & cxmask) HandleCx();
 666         if (sigs & actionmask) HandleAction(); /* "Action" == window moving or resizing */
 667         if (sigs & icontrolmask) HandleIControl();
 668         if (sigs & SIGBREAKF_CTRL_C) quitme = TRUE;
 669     } /* while(!quitme) */
 670 }
 671
 672 /************************************************************************************/
 673
 674 int main(int argc, char **argv)
 675 {
 676     Init();
 677
 678     nb.nb_Name = _(MSG_OPAQUE_CXNAME);
 679     nb.nb_Title = _(MSG_OPAQUE_CXTITLE);
 680     nb.nb_Descr = _(MSG_OPAQUE_CXDESCR);
 681
 682     GetArguments(argc, argv);
 683     InitCX();
 684     HandleAll();
 685     Cleanup(NULL);
 686     return 0;
 687 }
 688
 689 /************************************************************************************/
 690
 691 ADD2INIT(Locale_Initialize,   90);
 692 ADD2EXIT(Locale_Deinitialize, 90);
 693