workbench/utilities/MultiView/ARexx/MultiView_rxif.c

   1 /*
   2  * Source generated with ARexxBox 1.12 (May 18 1993)
   3  * which is Copyright (c) 1992,1993 Michael Balzer
   4  */
   5
   6 #include <exec/types.h>
   7 #include <exec/memory.h>
   8 #include <dos/dos.h>
   9 #include <rexx/storage.h>
  10 #include <rexx/rxslib.h>
  11
  12 #ifdef __GNUC__
  13 /* GCC needs all struct defs */
  14 #include <dos/exall.h>
  15 #include <graphics/graphint.h>
  16 #include <intuition/classes.h>
  17 #include <devices/keymap.h>
  18 #include <exec/semaphores.h>
  19 #endif
  20
  21 #include <clib/alib_protos.h>
  22 #include <clib/exec_protos.h>
  23 #include <clib/dos_protos.h>
  24 #include <clib/rexxsyslib_protos.h>
  25
  26 #ifndef __NO_PRAGMAS
  27
  28 #ifdef AZTEC_C
  29 #include <pragmas/exec_lib.h>
  30 #include <pragmas/dos_lib.h>
  31 #include <pragmas/rexxsyslib_lib.h>
  32 #endif
  33
  34 #ifdef LATTICE
  35 #include <pragmas/exec_pragmas.h>
  36 #include <pragmas/dos_pragmas.h>
  37 #include <pragmas/rexxsyslib_pragmas.h>
  38 #endif
  39
  40 #endif /* __NO_PRAGMAS */
  41
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45 #include <ctype.h>
  46
  47 #ifdef LATTICE
  48 #undef toupper
  49 #define inline __inline
  50 #endif
  51
  52 #ifdef __GNUC__
  53 #undef toupper
  54 static inline int toupper( int c )
  55 {
  56         return( islower(c) ? c - 'a' + 'A' : c );
  57 }
  58 #endif
  59
  60 #ifdef AZTEC_C
  61 #define inline
  62 #endif
  63
  64 #include "MultiView.h"
  65
  66
  67 extern struct ExecBase *SysBase;
  68 extern struct DosLibrary *DOSBase;
  69 extern struct RxsLib *RexxSysBase;
  70
  71
  72 /* $ARB: I 1191273255 */
  73
  74
  75 /* $ARB: B 1 OPEN */
  76 void rx_open( struct RexxHost *host, struct rxd_open **rxd, long action, struct RexxMsg *rexxmsg )
  77 {
  78         struct rxd_open *rd = *rxd;
  79
  80         switch( action )
  81         {
  82                 case RXIF_INIT:
  83                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  84                         if( rd = *rxd )
  85                         {
  86                                 /* set your DEFAULTS here */
  87                         }
  88                         break;
  89
  90                 case RXIF_ACTION:
  91                         /* Insert your CODE here */
  92                         rd->rc = 0;
  93                         break;
  94
  95                 case RXIF_FREE:
  96                         /* FREE your local data here */
  97                         FreeVec( rd );
  98                         break;
  99         }
 100         return;
 101 }
 102 /* $ARB: E 1 OPEN */
 103
 104 /* $ARB: B 2 RELOAD */
 105 void rx_reload( struct RexxHost *host, struct rxd_reload **rxd, long action, struct RexxMsg *rexxmsg )
 106 {
 107         struct rxd_reload *rd = *rxd;
 108
 109         switch( action )
 110         {
 111                 case RXIF_INIT:
 112                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 113                         break;
 114
 115                 case RXIF_ACTION:
 116                         /* Insert your CODE here */
 117                         rd->rc = 0;
 118                         break;
 119
 120                 case RXIF_FREE:
 121                         /* FREE your local data here */
 122                         FreeVec( rd );
 123                         break;
 124         }
 125         return;
 126 }
 127 /* $ARB: E 2 RELOAD */
 128
 129 /* $ARB: B 3 SAVEAS */
 130 void rx_saveas( struct RexxHost *host, struct rxd_saveas **rxd, long action, struct RexxMsg *rexxmsg )
 131 {
 132         struct rxd_saveas *rd = *rxd;
 133
 134         switch( action )
 135         {
 136                 case RXIF_INIT:
 137                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 138                         if( rd = *rxd )
 139                         {
 140                                 /* set your DEFAULTS here */
 141                         }
 142                         break;
 143
 144                 case RXIF_ACTION:
 145                         /* Insert your CODE here */
 146                         rd->rc = 0;
 147                         break;
 148
 149                 case RXIF_FREE:
 150                         /* FREE your local data here */
 151                         FreeVec( rd );
 152                         break;
 153         }
 154         return;
 155 }
 156 /* $ARB: E 3 SAVEAS */
 157
 158 /* $ARB: B 4 PRINT */
 159 void rx_print( struct RexxHost *host, struct rxd_print **rxd, long action, struct RexxMsg *rexxmsg )
 160 {
 161         struct rxd_print *rd = *rxd;
 162
 163         switch( action )
 164         {
 165                 case RXIF_INIT:
 166                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 167                         break;
 168
 169                 case RXIF_ACTION:
 170                         /* Insert your CODE here */
 171                         rd->rc = 0;
 172                         break;
 173
 174                 case RXIF_FREE:
 175                         /* FREE your local data here */
 176                         FreeVec( rd );
 177                         break;
 178         }
 179         return;
 180 }
 181 /* $ARB: E 4 PRINT */
 182
 183 /* $ARB: B 5 ABOUT */
 184 void rx_about( struct RexxHost *host, struct rxd_about **rxd, long action, struct RexxMsg *rexxmsg )
 185 {
 186         struct rxd_about *rd = *rxd;
 187
 188         switch( action )
 189         {
 190                 case RXIF_INIT:
 191                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 192                         break;
 193
 194                 case RXIF_ACTION:
 195                         /* Insert your CODE here */
 196                         rd->rc = 0;
 197                         break;
 198
 199                 case RXIF_FREE:
 200                         /* FREE your local data here */
 201                         FreeVec( rd );
 202                         break;
 203         }
 204         return;
 205 }
 206 /* $ARB: E 5 ABOUT */
 207
 208 /* $ARB: B 6 QUIT */
 209 void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
 210 {
 211         struct rxd_quit *rd = *rxd;
 212
 213         switch( action )
 214         {
 215                 case RXIF_INIT:
 216                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 217                         break;
 218
 219                 case RXIF_ACTION:
 220                         /* Insert your CODE here */
 221                         rd->rc = 0;
 222                         break;
 223
 224                 case RXIF_FREE:
 225                         /* FREE your local data here */
 226                         FreeVec( rd );
 227                         break;
 228         }
 229         return;
 230 }
 231 /* $ARB: E 6 QUIT */
 232
 233 /* $ARB: B 7 MARK */
 234 void rx_mark( struct RexxHost *host, struct rxd_mark **rxd, long action, struct RexxMsg *rexxmsg )
 235 {
 236         struct rxd_mark *rd = *rxd;
 237
 238         switch( action )
 239         {
 240                 case RXIF_INIT:
 241                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 242                         break;
 243
 244                 case RXIF_ACTION:
 245                         /* Insert your CODE here */
 246                         rd->rc = 0;
 247                         break;
 248
 249                 case RXIF_FREE:
 250                         /* FREE your local data here */
 251                         FreeVec( rd );
 252                         break;
 253         }
 254         return;
 255 }
 256 /* $ARB: E 7 MARK */
 257
 258 /* $ARB: B 8 COPY */
 259 void rx_copy( struct RexxHost *host, struct rxd_copy **rxd, long action, struct RexxMsg *rexxmsg )
 260 {
 261         struct rxd_copy *rd = *rxd;
 262
 263         switch( action )
 264         {
 265                 case RXIF_INIT:
 266                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 267                         break;
 268
 269                 case RXIF_ACTION:
 270                         /* Insert your CODE here */
 271                         rd->rc = 0;
 272                         break;
 273
 274                 case RXIF_FREE:
 275                         /* FREE your local data here */
 276                         FreeVec( rd );
 277                         break;
 278         }
 279         return;
 280 }
 281 /* $ARB: E 8 COPY */
 282
 283 /* $ARB: B 9 CLEARSELECTED */
 284 void rx_clearselected( struct RexxHost *host, struct rxd_clearselected **rxd, long action, struct RexxMsg *rexxmsg )
 285 {
 286         struct rxd_clearselected *rd = *rxd;
 287
 288         switch( action )
 289         {
 290                 case RXIF_INIT:
 291                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 292                         break;
 293
 294                 case RXIF_ACTION:
 295                         /* Insert your CODE here */
 296                         rd->rc = 0;
 297                         break;
 298
 299                 case RXIF_FREE:
 300                         /* FREE your local data here */
 301                         FreeVec( rd );
 302                         break;
 303         }
 304         return;
 305 }
 306 /* $ARB: E 9 CLEARSELECTED */
 307
 308 /* $ARB: B 10 GETTRIGGERINFO */
 309 void rx_gettriggerinfo( struct RexxHost *host, struct rxd_gettriggerinfo **rxd, long action, struct RexxMsg *rexxmsg )
 310 {
 311         struct rxd_gettriggerinfo *rd = *rxd;
 312
 313         switch( action )
 314         {
 315                 case RXIF_INIT:
 316                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 317                         if( rd = *rxd )
 318                         {
 319                                 /* set your DEFAULTS here */
 320                         }
 321                         break;
 322
 323                 case RXIF_ACTION:
 324                         /* Insert your CODE here */
 325                         rd->rc = 0;
 326                         break;
 327
 328                 case RXIF_FREE:
 329                         /* FREE your local data here */
 330                         FreeVec( rd );
 331                         break;
 332         }
 333         return;
 334 }
 335 /* $ARB: E 10 GETTRIGGERINFO */
 336
 337 /* $ARB: B 11 DOTRIGGERMETHOD */
 338 void rx_dotriggermethod( struct RexxHost *host, struct rxd_dotriggermethod **rxd, long action, struct RexxMsg *rexxmsg )
 339 {
 340         struct rxd_dotriggermethod *rd = *rxd;
 341
 342         switch( action )
 343         {
 344                 case RXIF_INIT:
 345                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 346                         if( rd = *rxd )
 347                         {
 348                                 /* set your DEFAULTS here */
 349                         }
 350                         break;
 351
 352                 case RXIF_ACTION:
 353                         /* Insert your CODE here */
 354                         rd->rc = 0;
 355                         break;
 356
 357                 case RXIF_FREE:
 358                         /* FREE your local data here */
 359                         FreeVec( rd );
 360                         break;
 361         }
 362         return;
 363 }
 364 /* $ARB: E 11 DOTRIGGERMETHOD */
 365
 366 /* $ARB: B 12 SCREEN */
 367 void rx_screen( struct RexxHost *host, struct rxd_screen **rxd, long action, struct RexxMsg *rexxmsg )
 368 {
 369         struct rxd_screen *rd = *rxd;
 370
 371         switch( action )
 372         {
 373                 case RXIF_INIT:
 374                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 375                         if( rd = *rxd )
 376                         {
 377                                 /* set your DEFAULTS here */
 378                         }
 379                         break;
 380
 381                 case RXIF_ACTION:
 382                         /* Insert your CODE here */
 383                         rd->rc = 0;
 384                         break;
 385
 386                 case RXIF_FREE:
 387                         /* FREE your local data here */
 388                         FreeVec( rd );
 389                         break;
 390         }
 391         return;
 392 }
 393 /* $ARB: E 12 SCREEN */
 394
 395 /* $ARB: B 13 PUBSCREEN */
 396 void rx_pubscreen( struct RexxHost *host, struct rxd_pubscreen **rxd, long action, struct RexxMsg *rexxmsg )
 397 {
 398         struct rxd_pubscreen *rd = *rxd;
 399
 400         switch( action )
 401         {
 402                 case RXIF_INIT:
 403                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 404                         if( rd = *rxd )
 405                         {
 406                                 /* set your DEFAULTS here */
 407                         }
 408                         break;
 409
 410                 case RXIF_ACTION:
 411                         /* Insert your CODE here */
 412                         rd->rc = 0;
 413                         break;
 414
 415                 case RXIF_FREE:
 416                         /* FREE your local data here */
 417                         FreeVec( rd );
 418                         break;
 419         }
 420         return;
 421 }
 422 /* $ARB: E 13 PUBSCREEN */
 423
 424 /* $ARB: B 14 SNAPSHOT */
 425 void rx_snapshot( struct RexxHost *host, struct rxd_snapshot **rxd, long action, struct RexxMsg *rexxmsg )
 426 {
 427         struct rxd_snapshot *rd = *rxd;
 428
 429         switch( action )
 430         {
 431                 case RXIF_INIT:
 432                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 433                         break;
 434
 435                 case RXIF_ACTION:
 436                         /* Insert your CODE here */
 437                         rd->rc = 0;
 438                         break;
 439
 440                 case RXIF_FREE:
 441                         /* FREE your local data here */
 442                         FreeVec( rd );
 443                         break;
 444         }
 445         return;
 446 }
 447 /* $ARB: E 14 SNAPSHOT */
 448
 449 /* $ARB: B 15 GETCURRENTDIR */
 450 void rx_getcurrentdir( struct RexxHost *host, struct rxd_getcurrentdir **rxd, long action, struct RexxMsg *rexxmsg )
 451 {
 452         struct rxd_getcurrentdir *rd = *rxd;
 453
 454         switch( action )
 455         {
 456                 case RXIF_INIT:
 457                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 458                         break;
 459
 460                 case RXIF_ACTION:
 461                         /* Insert your CODE here */
 462                         rd->rc = 0;
 463                         break;
 464
 465                 case RXIF_FREE:
 466                         /* FREE your local data here */
 467                         FreeVec( rd );
 468                         break;
 469         }
 470         return;
 471 }
 472 /* $ARB: E 15 GETCURRENTDIR */
 473
 474 /* $ARB: B 16 GETFILEINFO */
 475 void rx_getfileinfo( struct RexxHost *host, struct rxd_getfileinfo **rxd, long action, struct RexxMsg *rexxmsg )
 476 {
 477         struct rxd_getfileinfo *rd = *rxd;
 478
 479         switch( action )
 480         {
 481                 case RXIF_INIT:
 482                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 483                         break;
 484
 485                 case RXIF_ACTION:
 486                         /* Insert your CODE here */
 487                         rd->rc = 0;
 488                         break;
 489
 490                 case RXIF_FREE:
 491                         /* FREE your local data here */
 492                         FreeVec( rd );
 493                         break;
 494         }
 495         return;
 496 }
 497 /* $ARB: E 16 GETFILEINFO */
 498
 499 /* $ARB: B 17 GETOBJECTINFO */
 500 void rx_getobjectinfo( struct RexxHost *host, struct rxd_getobjectinfo **rxd, long action, struct RexxMsg *rexxmsg )
 501 {
 502         struct rxd_getobjectinfo *rd = *rxd;
 503
 504         switch( action )
 505         {
 506                 case RXIF_INIT:
 507                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 508                         if( rd = *rxd )
 509                         {
 510                                 /* set your DEFAULTS here */
 511                         }
 512                         break;
 513
 514                 case RXIF_ACTION:
 515                         /* Insert your CODE here */
 516                         rd->rc = 0;
 517                         break;
 518
 519                 case RXIF_FREE:
 520                         /* FREE your local data here */
 521                         FreeVec( rd );
 522                         break;
 523         }
 524         return;
 525 }
 526 /* $ARB: E 17 GETOBJECTINFO */
 527
 528 /* $ARB: B 18 MINIMUMSIZE */
 529 void rx_minimumsize( struct RexxHost *host, struct rxd_minimumsize **rxd, long action, struct RexxMsg *rexxmsg )
 530 {
 531         struct rxd_minimumsize *rd = *rxd;
 532
 533         switch( action )
 534         {
 535                 case RXIF_INIT:
 536                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 537                         break;
 538
 539                 case RXIF_ACTION:
 540                         /* Insert your CODE here */
 541                         rd->rc = 0;
 542                         break;
 543
 544                 case RXIF_FREE:
 545                         /* FREE your local data here */
 546                         FreeVec( rd );
 547                         break;
 548         }
 549         return;
 550 }
 551 /* $ARB: E 18 MINIMUMSIZE */
 552
 553 /* $ARB: B 19 NORMALSIZE */
 554 void rx_normalsize( struct RexxHost *host, struct rxd_normalsize **rxd, long action, struct RexxMsg *rexxmsg )
 555 {
 556         struct rxd_normalsize *rd = *rxd;
 557
 558         switch( action )
 559         {
 560                 case RXIF_INIT:
 561                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 562                         break;
 563
 564                 case RXIF_ACTION:
 565                         /* Insert your CODE here */
 566                         rd->rc = 0;
 567                         break;
 568
 569                 case RXIF_FREE:
 570                         /* FREE your local data here */
 571                         FreeVec( rd );
 572                         break;
 573         }
 574         return;
 575 }
 576 /* $ARB: E 19 NORMALSIZE */
 577
 578 /* $ARB: B 20 MAXIMUMSIZE */
 579 void rx_maximumsize( struct RexxHost *host, struct rxd_maximumsize **rxd, long action, struct RexxMsg *rexxmsg )
 580 {
 581         struct rxd_maximumsize *rd = *rxd;
 582
 583         switch( action )
 584         {
 585                 case RXIF_INIT:
 586                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 587                         break;
 588
 589                 case RXIF_ACTION:
 590                         /* Insert your CODE here */
 591                         rd->rc = 0;
 592                         break;
 593
 594                 case RXIF_FREE:
 595                         /* FREE your local data here */
 596                         FreeVec( rd );
 597                         break;
 598         }
 599         return;
 600 }
 601 /* $ARB: E 20 MAXIMUMSIZE */
 602
 603 /* $ARB: B 21 WINDOWTOFRONT */
 604 void rx_windowtofront( struct RexxHost *host, struct rxd_windowtofront **rxd, long action, struct RexxMsg *rexxmsg )
 605 {
 606         struct rxd_windowtofront *rd = *rxd;
 607
 608         switch( action )
 609         {
 610                 case RXIF_INIT:
 611                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 612                         break;
 613
 614                 case RXIF_ACTION:
 615                         /* Insert your CODE here */
 616                         rd->rc = 0;
 617                         break;
 618
 619                 case RXIF_FREE:
 620                         /* FREE your local data here */
 621                         FreeVec( rd );
 622                         break;
 623         }
 624         return;
 625 }
 626 /* $ARB: E 21 WINDOWTOFRONT */
 627
 628 /* $ARB: B 22 WINDOWTOBACK */
 629 void rx_windowtoback( struct RexxHost *host, struct rxd_windowtoback **rxd, long action, struct RexxMsg *rexxmsg )
 630 {
 631         struct rxd_windowtoback *rd = *rxd;
 632
 633         switch( action )
 634         {
 635                 case RXIF_INIT:
 636                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 637                         break;
 638
 639                 case RXIF_ACTION:
 640                         /* Insert your CODE here */
 641                         rd->rc = 0;
 642                         break;
 643
 644                 case RXIF_FREE:
 645                         /* FREE your local data here */
 646                         FreeVec( rd );
 647                         break;
 648         }
 649         return;
 650 }
 651 /* $ARB: E 22 WINDOWTOBACK */
 652
 653 /* $ARB: B 23 ACTIVATEWINDOW */
 654 void rx_activatewindow( struct RexxHost *host, struct rxd_activatewindow **rxd, long action, struct RexxMsg *rexxmsg )
 655 {
 656         struct rxd_activatewindow *rd = *rxd;
 657
 658         switch( action )
 659         {
 660                 case RXIF_INIT:
 661                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 662                         break;
 663
 664                 case RXIF_ACTION:
 665                         /* Insert your CODE here */
 666                         rd->rc = 0;
 667                         break;
 668
 669                 case RXIF_FREE:
 670                         /* FREE your local data here */
 671                         FreeVec( rd );
 672                         break;
 673         }
 674         return;
 675 }
 676 /* $ARB: E 23 ACTIVATEWINDOW */
 677
 678 /* $ARB: B 24 SCREENTOFRONT */
 679 void rx_screentofront( struct RexxHost *host, struct rxd_screentofront **rxd, long action, struct RexxMsg *rexxmsg )
 680 {
 681         struct rxd_screentofront *rd = *rxd;
 682
 683         switch( action )
 684         {
 685                 case RXIF_INIT:
 686                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 687                         break;
 688
 689                 case RXIF_ACTION:
 690                         /* Insert your CODE here */
 691                         rd->rc = 0;
 692                         break;
 693
 694                 case RXIF_FREE:
 695                         /* FREE your local data here */
 696                         FreeVec( rd );
 697                         break;
 698         }
 699         return;
 700 }
 701 /* $ARB: E 24 SCREENTOFRONT */
 702
 703 /* $ARB: B 25 SCREENTOBACK */
 704 void rx_screentoback( struct RexxHost *host, struct rxd_screentoback **rxd, long action, struct RexxMsg *rexxmsg )
 705 {
 706         struct rxd_screentoback *rd = *rxd;
 707
 708         switch( action )
 709         {
 710                 case RXIF_INIT:
 711                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 712                         break;
 713
 714                 case RXIF_ACTION:
 715                         /* Insert your CODE here */
 716                         rd->rc = 0;
 717                         break;
 718
 719                 case RXIF_FREE:
 720                         /* FREE your local data here */
 721                         FreeVec( rd );
 722                         break;
 723         }
 724         return;
 725 }
 726 /* $ARB: E 25 SCREENTOBACK */
 727
 728 /* $ARB: B 26 BEEPSCREEN */
 729 void rx_beepscreen( struct RexxHost *host, struct rxd_beepscreen **rxd, long action, struct RexxMsg *rexxmsg )
 730 {
 731         struct rxd_beepscreen *rd = *rxd;
 732
 733         switch( action )
 734         {
 735                 case RXIF_INIT:
 736                         *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
 737                         break;
 738
 739                 case RXIF_ACTION:
 740                         /* Insert your CODE here */
 741                         rd->rc = 0;
 742                         break;
 743
 744                 case RXIF_FREE:
 745                         /* FREE your local data here */
 746                         FreeVec( rd );
 747                         break;
 748         }
 749         return;
 750 }
 751 /* $ARB: E 26 BEEPSCREEN */
 752
 753
 754 #ifndef RX_ALIAS_C
 755 char *ExpandRXCommand( struct RexxHost *host, char *command )
 756 {
 757         /* Insert your ALIAS-HANDLER here */
 758         return( NULL );
 759 }
 760 #endif
 761