bgui/commodityclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * commodityclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.5  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.4  2003/01/18 19:09:56  chodorowski
  18  * Instead of using the _AROS or __AROS preprocessor symbols, use __AROS__.
  19  *
  20  * Revision 42.3  2000/05/29 00:40:23  bergers
  21  * Update to compile with AROS now. Should also still compile with SASC etc since I only made changes that test the define __AROS__. The compilation is still very noisy but it does the trick for the main directory. Maybe members of the BGUI team should also have a look at the compiler warnings because some could also cause problems on other systems... (Comparison always TRUE due to datatype (or something like that)). And please compile it on an Amiga to see whether it still works... Thanks.
  22  *
  23  * Revision 42.2  2000/05/15 19:27:01  stegerg
  24  * another hundreds of REG() macro replacements in func headers/protos.
  25  *
  26  * Revision 42.1  2000/05/14 23:32:47  stegerg
  27  * changed over 200 function headers which all use register
  28  * parameters (oh boy ...), because the simple REG() macro
  29  * doesn't work with AROS. And there are still hundreds
  30  * of headers left to be fixed :(
  31  *
  32  * Many of these functions would also work with stack
  33  * params, but since i have fixed every single one
  34  * I encountered up to now, I guess will have to do
  35  * the same for the rest.
  36  *
  37  * Revision 42.0  2000/05/09 22:08:41  mlemos
  38  * Bumped to revision 42.0 before handing BGUI to AROS team
  39  *
  40  * Revision 41.11  2000/05/09 19:54:06  mlemos
  41  * Merged with the branch Manuel_Lemos_fixes.
  42  *
  43  * Revision 41.10  1998/02/25 21:11:50  mlemos
  44  * Bumping to 41.10
  45  *
  46  * Revision 1.1  1998/02/25 17:07:55  mlemos
  47  * Ian sources
  48  *
  49  *
  50  */
  51
  52 #include "include/classdefs.h"
  53
  54 /*
  55  * Internal storage of the Hotkeys.
  56  */
  57 typedef struct Key {
  58    struct Key     *k_Next;    /* next key       */
  59    struct Key     *k_Prev;    /* previous key                 */
  60    CxObj       *k_Object;     /* The CxObj         */
  61    ULONG        k_KeyID;      /* key ID         */
  62    ULONG        k_Flags;      /* control flags     */
  63 }  KEY;
  64
  65 typedef struct {
  66    KEY         *kl_First;     /* first key         */
  67    KEY         *kl_EndMark;      /* end marker        */
  68    KEY         *kl_Last;      /* last key       */
  69 }  KEYLIST;
  70
  71 /*
  72  * Object instance data.
  73  */
  74 typedef struct {
  75    KEYLIST            cd_Hotkeys;      /* list of keys         */
  76    struct NewBroker   cd_Broker;       /* NewBroker structure  */
  77    CxObj             *cd_BrokerPtr;    /* points to broker     */
  78    ULONG              cd_ErrorCode;    /* error code           */
  79    ULONG              cd_Flags;        /* control flags        */
  80 } CD;
  81
  82 #define CDF_BROKERON    (1<<0)            /* broker is active     */
  83
  84 /*
  85  * For PackBoolTags().
  86  */
  87 STATIC struct TagItem BoolTags[] = {
  88    { COMM_Unique,       NBU_UNIQUE, },
  89    { COMM_Notify,       NBU_NOTIFY, },
  90    { TAG_DONE },
  91 };
  92
  93 /*
  94  * Module prototypes.
  95  */
  96
  97 /*
  98  * Create a shiny new object.
  99  */
 100 METHOD(CommClassNew, struct opSet *, ops)
 101 {
 102    CD                *cd;
 103    IPTR               rc, data;
 104    ULONG              un = NBU_UNIQUE | NBU_NOTIFY;
 105    struct TagItem *tstate = ops->ops_AttrList;
 106    struct TagItem    *tag;
 107
 108    /*
 109     * First we let the superclass
 110     * setup an object.
 111     */
 112    if ((rc = AsmDoSuperMethodA(cl, obj, (Msg)ops)))
 113    {
 114       /*
 115        * Get the instance data.
 116        */
 117       cd = INST_DATA(cl, rc);
 118
 119       /*
 120        * Initialize Hotkey list.
 121        */
 122       NewList((struct List *)&cd->cd_Hotkeys);
 123
 124       /*
 125        * Get us a message port.
 126        */
 127       if ((cd->cd_Broker.nb_Port = CreateMsgPort()))
 128       {
 129          /*
 130           * Initialize the broker.
 131           */
 132          cd->cd_Broker.nb_Version = NB_VERSION;
 133
 134          while ((tag = NextTagItem(&tstate)))
 135          {
 136             data = tag->ti_Data;
 137             switch (tag->ti_Tag)
 138             {
 139             case COMM_Name:
 140                cd->cd_Broker.nb_Name = (BYTE *)data;
 141                break;
 142
 143             case COMM_Title:
 144                cd->cd_Broker.nb_Title = (BYTE *)data;
 145                break;
 146
 147             case COMM_Description:
 148                cd->cd_Broker.nb_Descr = (BYTE *)data;
 149                break;
 150
 151             case COMM_Priority:
 152                cd->cd_Broker.nb_Pri = (BYTE)data;
 153                break;
 154
 155             case COMM_ShowHide:
 156                if (data)
 157                   cd->cd_Broker.nb_Flags = COF_SHOW_HIDE;
 158                break;
 159             }
 160          };
 161
 162          /*
 163           * Setup broker flags.
 164           */
 165          cd->cd_Broker.nb_Unique = PackBoolTags(un, ops->ops_AttrList, BoolTags);
 166
 167          /*
 168           * Setup broker.
 169           */
 170          if ((cd->cd_BrokerPtr = CxBroker(&cd->cd_Broker, NULL)))
 171             return rc;
 172       }
 173       /*
 174        * Major screwup.
 175        */
 176       AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
 177    }
 178    return 0;
 179 }
 180 METHOD_END
 181
 182 /*
 183  * Get rid of an object.
 184  */
 185 METHOD(CommClassDispose, Msg,  msg)
 186 {
 187    CD                *cd = INST_DATA( cl, obj );
 188    struct MsgPort    *mp;
 189    struct Message    *tmp;
 190    KEY               *key;
 191
 192    /*
 193     * Scan through the list of keys.
 194     */
 195    while (( key = ( KEY * )RemHead(( struct List * )&cd->cd_Hotkeys ))) {
 196       /*
 197        * Enabled?
 198        */
 199       if ( ! ( key->k_Flags & CAHF_DISABLED ))
 200          /*
 201           * Yes. Remove it.
 202           */
 203          RemoveCxObj( key->k_Object );
 204       /*
 205        * Delete the CxObj.
 206        */
 207       DeleteCxObjAll( key->k_Object );
 208
 209       /*
 210        * Deallocate the KEY structure.
 211        */
 212       BGUI_FreePoolMem( key );
 213    }
 214
 215    /*
 216     * De-activate and delete the broker.
 217     */
 218    if ( cd->cd_BrokerPtr ) {
 219       if ( cd->cd_Flags & CDF_BROKERON )
 220          ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 221       DeleteCxObjAll( cd->cd_BrokerPtr );
 222    }
 223
 224    /*
 225     * Strip the remaining messages.
 226     */
 227    if (( mp = cd->cd_Broker.nb_Port )) {
 228       while (( tmp = GetMsg( mp ))) ReplyMsg( tmp );
 229       DeleteMsgPort( mp );
 230    }
 231
 232    /*
 233     * The superclass takes care of the rest.
 234     */
 235    return( AsmDoSuperMethodA( cl, obj, msg ));
 236 }
 237 METHOD_END
 238
 239 /*
 240  * They want something.
 241  */
 242
 243 STATIC METHOD(CommClassGet, struct opGet *, opg)
 244 {
 245    CD       *cd = ( CD * )INST_DATA( cl, obj );
 246    ULONG     rc = 1L;
 247    IPTR     *store = opg->opg_Storage;
 248
 249    switch ( opg->opg_AttrID ) {
 250
 251       case  COMM_SigMask:
 252          *store = ( ULONG )( 1L << cd->cd_Broker.nb_Port->mp_SigBit );
 253          break;
 254
 255       case  COMM_ErrorCode:
 256          *store = cd->cd_ErrorCode;
 257          break;
 258
 259       default:
 260          rc = AsmDoSuperMethodA( cl, obj, ( Msg )opg );
 261          break;
 262    }
 263    return( rc );
 264 }
 265 METHOD_END
 266
 267 /*
 268  * Search for a key by it's ID.
 269  */
 270 STATIC ASM KEY *FindKey( REG(a0) KEYLIST *kl, REG(d0) ULONG keyID )
 271 {
 272    KEY         *key;
 273
 274    for ( key = kl->kl_First; key->k_Next; key = key->k_Next ) {
 275       if ( keyID == key->k_KeyID )
 276          return( key );
 277    }
 278    return( NULL );
 279 }
 280
 281 /*
 282  * Add a hotkey to the list.
 283  */
 284
 285 STATIC METHOD(CommClassAddHotkey, struct cmAddHotkey *, cah)
 286 {
 287    CD       *cd = ( CD * )INST_DATA( cl, obj );
 288    KEY         *key;
 289
 290    /*
 291     * Deactivate the broker if active.
 292     */
 293    if ( cd->cd_Flags & CDF_BROKERON )
 294       ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 295
 296    /*
 297     * Key ID's must be unique.
 298     */
 299    if ( ! FindKey( &cd->cd_Hotkeys, cah->cah_KeyID )) {
 300       /*
 301        * Allocate a KEY structure.
 302        */
 303       if (( key = ( KEY * )BGUI_AllocPoolMem( sizeof( KEY )))) {
 304          /*
 305           * Setup the key.
 306           */
 307          if (( key->k_Object = HotKey( cah->cah_InputDescription, cd->cd_Broker.nb_Port, cah->cah_KeyID ))) {
 308             /*
 309              * Initialize the KEY structure.
 310              */
 311             key->k_Flags = cah->cah_Flags;
 312             key->k_KeyID = cah->cah_KeyID;
 313
 314             /*
 315              * Add the key when necessary.
 316              */
 317             if ( ! ( key->k_Flags & CAHF_DISABLED ))
 318                AttachCxObj( cd->cd_BrokerPtr, key->k_Object );
 319
 320             /*
 321              * An error occured?
 322              */
 323             if ( ! CxObjError( key->k_Object )) {
 324                /*
 325                 * No. Add the key to the list.
 326                 */
 327                AddTail(( struct List * )&cd->cd_Hotkeys, ( struct Node * )key );
 328
 329                /*
 330                 * Clear the error code.
 331                 */
 332                cd->cd_ErrorCode = CMERR_OK;
 333
 334                /*
 335                 * Activate the broker if necessary.
 336                 */
 337                if ( cd->cd_Flags & CDF_BROKERON )
 338                   ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 339                return 1;
 340             } else
 341                /*
 342                 * Error from CxObjError();
 343                 */
 344                cd->cd_ErrorCode = CMERR_CXOBJERROR;
 345             /*
 346              * Remove and dispose of the Cx
 347              * object.
 348              */
 349             if ( ! ( key->k_Flags & CAHF_DISABLED ))
 350                RemoveCxObj( key->k_Object );
 351             DeleteCxObjAll( key->k_Object );
 352          } else
 353             cd->cd_ErrorCode = CMERR_KEY_CREATION;
 354          /*
 355           * Free memory.
 356           */
 357          BGUI_FreePoolMem( key );
 358       } else
 359          cd->cd_ErrorCode = CMERR_NO_MEMORY;
 360    } else
 361       cd->cd_ErrorCode = CMERR_KEYID_IN_USE;
 362
 363    /*
 364     * Re-activate the broker if necessary.
 365     */
 366    if ( cd->cd_Flags & CDF_BROKERON )
 367       ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 368
 369    return 0;
 370 }
 371 METHOD_END
 372
 373 /*
 374  * Remove a hotkey from the list.
 375  */
 376 STATIC METHOD(CommClassRemHotkey, struct cmDoKeyCommand *, com)
 377 {
 378    CD       *cd = ( CD * )INST_DATA( cl, obj );
 379    KEY         *key;
 380    ULONG        rc = 0L;
 381
 382    /*
 383     * Deactivate the broker if necessary.
 384     */
 385    if ( cd->cd_Flags & CDF_BROKERON )
 386       ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 387
 388    /*
 389     * Locate the key.
 390     */
 391    if (( key = FindKey( &cd->cd_Hotkeys, com->cdkc_KeyID ))) {
 392       /*
 393        * Remove it from the list.
 394        */
 395       Remove(( struct Node * )key );
 396
 397       /*
 398        * Remove the CxObj when necessary.
 399        */
 400       if ( ! ( key->k_Flags & CAHF_DISABLED ))
 401          RemoveCxObj( key->k_Object );
 402
 403       /*
 404        * Delete the CxObj.
 405        */
 406       DeleteCxObjAll( key->k_Object );
 407
 408       /*
 409        * Deallocate the KEY structure.
 410        */
 411       BGUI_FreePoolMem( key );
 412       rc = 1L;
 413    }
 414
 415    /*
 416     * Activate the broker if necessary.
 417     */
 418    if ( cd->cd_Flags & CDF_BROKERON )
 419       ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 420
 421    return( rc );
 422 }
 423 METHOD_END
 424
 425 /*
 426  * Disable a hotkey.
 427  */
 428 STATIC METHOD(CommClassDisableHotkey, struct cmDoKeyCommand *, com)
 429 {
 430    CD       *cd = ( CD * )INST_DATA( cl, obj );
 431    KEY         *key;
 432    ULONG        rc = 0L;
 433
 434    /*
 435     * Deactivate the broker if necessary.
 436     */
 437    if ( cd->cd_Flags & CDF_BROKERON )
 438       ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 439
 440    /*
 441     * Locate the key.
 442     */
 443    if (( key = FindKey( &cd->cd_Hotkeys, com->cdkc_KeyID ))) {
 444       /*
 445        * Only disable when the key is enabled.
 446        */
 447       if ( ! ( key->k_Flags & CAHF_DISABLED )) {
 448          /*
 449           * Remove the key.
 450           */
 451          RemoveCxObj( key->k_Object );
 452
 453          /*
 454           * Mark it as disabled.
 455           */
 456          key->k_Flags |= CAHF_DISABLED;
 457          rc = 1;
 458       }
 459    }
 460
 461    /*
 462     * Activate the broker if necessary.
 463     */
 464    if ( cd->cd_Flags & CDF_BROKERON )
 465       ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 466
 467    return( rc );
 468 }
 469 METHOD_END
 470
 471 /*
 472  * Enable a hotkey.
 473  */
 474
 475 STATIC METHOD(CommClassEnableHotkey, struct cmDoKeyCommand *, com)
 476 {
 477    CD       *cd = ( CD * )INST_DATA( cl, obj );
 478    KEY         *key;
 479    ULONG        rc = 0L;
 480
 481    /*
 482     * Deactivate the broker if necessary.
 483     */
 484    if ( cd->cd_Flags & CDF_BROKERON )
 485       ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 486
 487    /*
 488     * Locate the key.
 489     */
 490    if (( key = FindKey( &cd->cd_Hotkeys, com->cdkc_KeyID ))) {
 491       /*
 492        * Only enable when the key is disabled.
 493        */
 494       if ( key->k_Flags & CAHF_DISABLED ) {
 495          /*
 496           * Add the key.
 497           */
 498          AttachCxObj( cd->cd_BrokerPtr, key->k_Object );
 499
 500          /*
 501           * Clear the disabled bit.
 502           */
 503          key->k_Flags &= ~CAHF_DISABLED;
 504          rc = 1L;
 505       }
 506    }
 507
 508    /*
 509     * Activate the broker if necessary.
 510     */
 511    if ( cd->cd_Flags & CDF_BROKERON )
 512       ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 513
 514    return( rc );
 515 }
 516 METHOD_END
 517
 518 /*
 519  * Enable the broker.
 520  */
 521 STATIC METHOD(CommClassEnableBroker, Msg, msg)
 522 {
 523    CD       *cd = ( CD * )INST_DATA( cl, obj );
 524    ULONG        rc = 0L;
 525
 526    /*
 527     * Only enable when the broker is disabled.
 528     */
 529    if ( ! ( cd->cd_Flags & CDF_BROKERON )) {
 530       /*
 531        * Activate the broker.
 532        */
 533       ActivateCxObj( cd->cd_BrokerPtr, TRUE );
 534
 535       /*
 536        * Mark us as active.
 537        */
 538       cd->cd_Flags |= CDF_BROKERON;
 539       rc = 1L;
 540    }
 541    return( rc );
 542 }
 543 METHOD_END
 544
 545 /*
 546  * Disable the broker.
 547  */
 548 STATIC METHOD(CommClassDisableBroker, Msg, msg)
 549 {
 550    CD       *cd = ( CD * )INST_DATA( cl, obj );
 551    ULONG        rc = 0L;
 552
 553    /*
 554     * Only disable when the broker is enabled.
 555     */
 556    if ( cd->cd_Flags & CDF_BROKERON ) {
 557       /*
 558        * Deactivate the broker.
 559        */
 560       ActivateCxObj( cd->cd_BrokerPtr, FALSE );
 561
 562       /*
 563        * Clear the enabled bit.
 564        */
 565       cd->cd_Flags &= ~CDF_BROKERON;
 566       rc = 1L;
 567    }
 568    return( rc );
 569 }
 570 METHOD_END
 571
 572 /*
 573  * Poll broker port.
 574  */
 575 STATIC METHOD(CommClassMsgInfo, struct cmMsgInfo*, cmi)
 576 {
 577    CD          *cd = ( CD * )INST_DATA( cl, obj );
 578    CxMsg       *msg;
 579    ULONG        rc = 0, type, id;
 580    IPTR         data;
 581
 582    /*
 583     * Get a message from the port.
 584     */
 585    if (( msg = ( CxMsg * )GetMsg( cd->cd_Broker.nb_Port ))) {
 586       /*
 587        * Get message data.
 588        */
 589       type = CxMsgType(msg);
 590       id   = CxMsgID(msg);
 591       data = (IPTR)CxMsgData(msg);
 592
 593       /*
 594        * Save data where ever possible.
 595        */
 596       if ( cmi->cmi_Info.Type ) *( cmi->cmi_Info.Type ) = type;
 597       if ( cmi->cmi_Info.ID   ) *( cmi->cmi_Info.ID   ) = id;
 598       if ( cmi->cmi_Info.Data ) *( cmi->cmi_Info.Data ) = data;
 599
 600       /*
 601        * Setup V40 return codes.
 602        */
 603       switch (type)
 604       {
 605       case CXM_IEVENT:
 606          rc = id;
 607          break;
 608
 609       case CXM_COMMAND:
 610          switch(id)
 611          {
 612          case CXCMD_KILL:
 613             rc = CMMI_KILL;
 614             break;
 615
 616          case CXCMD_DISABLE:
 617             AsmDoMethod(obj, CM_DISABLEBROKER);
 618             rc = CMMI_DISABLE;
 619             break;
 620
 621          case CXCMD_ENABLE:
 622             AsmDoMethod(obj, CM_ENABLEBROKER);
 623             rc = CMMI_ENABLE;
 624             break;
 625
 626          case CXCMD_UNIQUE:
 627             rc = CMMI_UNIQUE;
 628             break;
 629
 630          case CXCMD_APPEAR:
 631             rc = CMMI_APPEAR;
 632             break;
 633
 634          case CXCMD_DISAPPEAR:
 635             rc = CMMI_DISAPPEAR;
 636             break;
 637          }
 638          break;
 639       }
 640
 641       /*
 642        * Reply the message.
 643        */
 644       ReplyMsg(( struct Message *)msg );
 645    } else
 646       /*
 647        * No more messages.
 648        */
 649       rc = CMMI_NOMORE;
 650
 651    return( rc );
 652 }
 653 METHOD_END
 654
 655 /*
 656  * Class function table.
 657  */
 658 STATIC DPFUNC ClassFunc[] = {
 659    { OM_NEW,           CommClassNew, },
 660    { OM_GET,           CommClassGet, },
 661    { OM_DISPOSE,       CommClassDispose, },
 662    { CM_ADDHOTKEY,     CommClassAddHotkey, },
 663    { CM_REMHOTKEY,     CommClassRemHotkey, },
 664    { CM_DISABLEHOTKEY, CommClassDisableHotkey, },
 665    { CM_ENABLEHOTKEY,  CommClassEnableHotkey, },
 666    { CM_DISABLEBROKER, CommClassDisableBroker, },
 667    { CM_ENABLEBROKER,  CommClassEnableBroker, },
 668    { CM_MSGINFO,       CommClassMsgInfo, },
 669    { DF_END,                 NULL },
 670 };
 671
 672 /*
 673  * Simple class initialization.
 674  */
 675 makeproto Class *InitCxClass(void)
 676 {
 677    return BGUI_MakeClass(CLASS_ObjectSize, sizeof(CD),
 678                          CLASS_DFTable,    ClassFunc,
 679                          TAG_DONE);
 680 }
 681
 682