rom/devs/console/consoleclass.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Base class for console units
   6     Lang: english
   7 */
   8
   9 #include <string.h>
  10
  11 #include <proto/intuition.h>
  12 #include <proto/utility.h>
  13 #include <aros/asmcall.h>
  14 #include <devices/conunit.h>
  15 #include <intuition/classes.h>
  16 #include <intuition/intuition.h>
  17
  18 #define SDEBUG 0
  19 #define DEBUG 0
  20 #include <aros/debug.h>
  21
  22 #include "consoleif.h"
  23 #include "console_gcc.h"
  24
  25
  26
  27 VOID normalizecoords(Object *o, WORD *x_ptr, WORD *y_ptr);
  28
  29 /*
  30    Base class for the classes handling standard, charmap and snipmap
  31    consoles. This is a whitebox base class (like GADGETCLASS), which means subclasses
  32    can have direct access to its instance data.
  33 */
  34
  35 struct consoledata
  36 {
  37     struct intConUnit intunit;
  38 };
  39
  40
  41 #undef ConsoleDevice
  42 #define ConsoleDevice ((struct ConsoleBase *)cl->cl_UserData)
  43
  44 /*********************
  45 **  Console::New()  **
  46 *********************/
  47 static Object *console_new(Class *cl, Object *o, struct opSet *msg)
  48 {
  49     struct Window *win;
  50     EnterFunc(bug("Console::New()\n"));
  51     struct Library *UtilityBase;
  52
  53     UtilityBase = TaggedOpenLibrary(TAGGEDOPEN_UTILITY);
  54     if (!UtilityBase)
  55         ReturnPtr ("Console::New", Object *, NULL);
  56
  57     /* Get console window */
  58     win = (struct Window *)GetTagData(A_Console_Window, 0, msg->ops_AttrList);
  59     CloseLibrary(UtilityBase);
  60     if (!win) {
  61         ReturnPtr ("Console::New", Object *, NULL);
  62     }
  63
  64     o = (Object *)DoSuperMethodA(cl, o, (Msg)msg);
  65     if (o)
  66     {
  67         struct ConUnit          *unit;
  68         struct consoledata      *data;
  69         struct RastPort         *rp = win->RPort;
  70         WORD                    i;
  71
  72         data = INST_DATA(cl, o);
  73
  74         unit = (struct ConUnit *)data;
  75
  76         memset(data, 0, sizeof(struct consoledata));
  77
  78         /* Initialize the unit fields */
  79         unit->cu_Window = win;
  80
  81
  82         /* For now one should use only non-proportional fonts */
  83         unit->cu_XRSize = rp->Font->tf_XSize;
  84         unit->cu_YRSize = rp->Font->tf_YSize;
  85
  86         D(bug("cu_XRSize: %d, cu_YRSize: %d\n",
  87                 unit->cu_XRSize, unit->cu_YRSize));
  88
  89         /* Use whole window for console. */
  90         unit->cu_XMax     = (win->Width  - (win->BorderLeft + win->BorderRight )) / unit->cu_XRSize - 1;
  91         unit->cu_YMax     = (win->Height - (win->BorderTop  + win->BorderBottom)) / unit->cu_YRSize - 1;
  92
  93         unit->cu_XROrigin = win->Flags & WFLG_GIMMEZEROZERO ? 0 : win->BorderLeft;
  94         unit->cu_YROrigin = win->Flags & WFLG_GIMMEZEROZERO ? 0 : win->BorderTop;
  95
  96         D(bug("cu_XROrigin: %d, cu_YROrigin: %d\n",
  97         unit->cu_XROrigin, unit->cu_YROrigin));
  98
  99         unit->cu_XRExtant = unit->cu_XROrigin + (unit->cu_XRSize * (unit->cu_XMax + 1) - 1);
 100         unit->cu_YRExtant = unit->cu_YROrigin  + (unit->cu_YRSize * (unit->cu_YMax + 1) - 1);
 101
 102         unit->cu_XCP = DEF_CHAR_XMIN;
 103         unit->cu_YCP = DEF_CHAR_YMIN;
 104
 105         unit->cu_XCCP = DEF_CHAR_XMIN;
 106         unit->cu_YCCP = DEF_CHAR_YMIN;
 107
 108         for(i = 0; i < MAXTABS - 1; i++)
 109         {
 110             unit->cu_TabStops[i] = i * 8;
 111         }
 112         unit->cu_TabStops[i] = (UWORD)-1;
 113
 114         ICU(o)->conFlags = 0UL;
 115         ICU(o)->numStoredChars = 0;
 116
 117         NEWLIST(&ICU(o)->pasteData);
 118
 119         SET_MODE(o, PMB_ASM); /* auto-scroll-mode ON */
 120         SET_MODE(o, PMB_AWM); /* auto-wrap-mode ON */
 121
 122         /* RKM: Default mode is SET */
 123         SET_MODE(o, M_LNM); /* linefeed mode = linefeed+carriage return */
 124     }
 125
 126     ReturnPtr("Console::New", Object *, o);
 127 }
 128
 129 /**********************
 130 **  Console::Left()  **
 131 **********************/
 132 static VOID console_left(Class *cl, Object *o, struct P_Console_Left *msg)
 133 {
 134     WORD newx;
 135
 136     EnterFunc(bug("Console::Left()\n"));
 137
 138     newx = XCCP - msg->Num;
 139
 140     if (CHECK_MODE(o, PMB_AWM))
 141     {
 142         WORD scrollcount = 0;
 143
 144         while(newx < CHAR_XMIN(o))
 145         {
 146             newx += (CHAR_XMAX(o) + 1);
 147             scrollcount++;
 148         }
 149
 150         XCP = XCCP = newx;
 151
 152         Console_Up(o, scrollcount);
 153
 154     }
 155     else
 156     {
 157         if (newx < CHAR_XMIN(o)) newx = CHAR_XMIN(o);
 158     }
 159
 160     XCP = XCCP = newx; /* XCP always same as XCCP?? */
 161
 162     D(bug("XCP=%d, XCCP=%d\n", XCP, XCCP));
 163
 164     ReturnVoid("Console::Left");
 165 }
 166
 167 /***********************
 168 **  Console::Right()  **
 169 ***********************/
 170 static VOID console_right(Class *cl, Object *o, struct P_Console_Right *msg)
 171 {
 172     WORD newx;
 173
 174     EnterFunc(bug("Console::Right()\n"));
 175
 176     newx = XCCP + msg->Num;
 177
 178     if (CHECK_MODE(o, PMB_AWM))
 179     {
 180         WORD scrollcount = 0;
 181
 182         while(newx > CHAR_XMAX(o))
 183         {
 184             newx -= (CHAR_XMAX(o) + 1);
 185             scrollcount++;
 186         }
 187
 188         XCP = XCCP = newx;
 189
 190         Console_Down(o, scrollcount);
 191
 192     }
 193     else
 194     {
 195         if (newx > CHAR_XMAX(o)) newx = CHAR_XMAX(o);
 196     }
 197
 198     XCP = XCCP = newx; /* XCP always same as XCCP?? */
 199
 200     D(bug("XCP=%d, XCCP=%d\n", XCP, XCCP));
 201
 202     ReturnVoid("Console::Right");
 203 }
 204
 205 /********************
 206 **  Console::Up()  **
 207 ********************/
 208 static VOID console_up(Class *cl, Object *o, struct P_Console_Up *msg)
 209 {
 210     EnterFunc(bug("Console::Up(num=%d)\n", msg->Num));
 211
 212     YCCP -= msg->Num;
 213
 214     if (YCCP < 0)
 215     {
 216         if (CHECK_MODE(o, PMB_ASM))
 217         {
 218             IPTR scroll_param = -YCCP;
 219
 220             YCCP = YCP = 0;
 221             Console_DoCommand(o, C_SCROLL_DOWN, 1, &scroll_param);
 222         }
 223         else
 224         {
 225             YCCP = 0;
 226         }
 227     }
 228     YCP = YCCP; /* YCP always same as YCCP ?? */
 229
 230     D(bug("New coords: char (%d, %d), gfx (%d, %d)\n",
 231         XCCP, YCCP, CP_X(o), CP_Y(o) ));
 232     ReturnVoid("Console::Up");
 233 }
 234
 235
 236
 237 /**********************
 238 **  Console::Down()  **
 239 **********************/
 240 static VOID console_down(Class *cl, Object *o, struct P_Console_Down *msg)
 241 {
 242     EnterFunc(bug("Console::Down(num=%d)\n", msg->Num));
 243
 244     YCCP += msg->Num;
 245
 246     if (YCCP > CHAR_YMAX(o))
 247     {
 248         if (CHECK_MODE(o, PMB_ASM))
 249         {
 250             IPTR scroll_param = YCCP - CHAR_YMAX(o);
 251
 252             YCCP = YCP = CHAR_YMAX(o);
 253             Console_DoCommand(o, C_SCROLL_UP, 1, &scroll_param);
 254         }
 255         else
 256         {
 257             YCCP = CHAR_YMAX(o);
 258         }
 259     }
 260     YCP = YCCP; /* YCP always same as YCCP ?? */
 261
 262     D(bug("New coords: char (%d, %d), gfx (%d, %d)\n",
 263         XCCP, YCCP, CP_X(o), CP_Y(o) ));
 264     ReturnVoid("Console::Down");
 265 }
 266
 267 /***************************
 268 **  Console::DoCommand()  **
 269 ***************************/
 270 static VOID console_docommand(Class *cl, Object *o, struct P_Console_DoCommand *msg)
 271 {
 272     EnterFunc(bug("Console::DoCommand(cmd=%d)\n", msg->Command));
 273
 274     switch (msg->Command)
 275     {
 276         case C_SET_LF_MODE:
 277             D(bug("Set LF mode ON\n"));
 278             /* LF==LF+CR */
 279             /* ICU(o)->conFlags |= CF_LF_MODE_ON ; */
 280             SET_MODE(o, M_LNM);
 281             break;
 282
 283         case C_RESET_LF_MODE:
 284             /* LF==LF */
 285             D(bug("Set LF mode OFF\n"));
 286             /* ICU(o)->conFlags &= ~CF_LF_MODE_ON; */
 287             CLEAR_MODE(o, M_LNM);
 288             break;
 289
 290         case C_SET_AUTOSCROLL_MODE:
 291             SET_MODE(o, PMB_ASM);
 292             break;
 293
 294         case C_RESET_AUTOSCROLL_MODE:
 295             CLEAR_MODE(o, PMB_ASM);
 296             break;
 297
 298         case C_SET_AUTOWRAP_MODE:
 299             SET_MODE(o, PMB_AWM);
 300             break;
 301
 302         case C_RESET_AUTOWRAP_MODE:
 303             CLEAR_MODE(o, PMB_AWM);
 304             break;
 305
 306         case C_SELECT_GRAPHIC_RENDITION:
 307             D(bug("Select graphic Rendition, params=%d\n", msg->NumParams));
 308             {
 309                 UBYTE i, param;
 310
 311                 for(i = 0; i < msg->NumParams; i++)
 312                 {
 313                     param = msg->Params[i];
 314                     D(bug("param%d=%d\n", i, param));
 315
 316                     switch(param)
 317                     {
 318                     case 0:
 319                       CU(o)->cu_FgPen = 1;
 320                       CU(o)->cu_BgPen = 0;
 321                       CU(o)->cu_TxFlags = 0;
 322                       break;
 323                     case 1:
 324                       CU(o)->cu_TxFlags |= CON_TXTFLAGS_BOLD;
 325                       break;
 326                     case 2:
 327                       /* Set "faint" */
 328                       break;
 329                     case 3:
 330                       CU(o)->cu_TxFlags |= CON_TXTFLAGS_ITALIC;
 331                       break;
 332                     case 4:
 333                       CU(o)->cu_TxFlags |= CON_TXTFLAGS_UNDERLINED;
 334                       break;
 335                     case 7:
 336                       CU(o)->cu_TxFlags |= CON_TXTFLAGS_REVERSED;
 337                       break;
 338                     case 8:
 339                       CU(o)->cu_TxFlags |= CON_TXTFLAGS_CONCEALED;
 340                       break;
 341                     case 22:
 342                       CU(o)->cu_TxFlags &= ~CON_TXTFLAGS_BOLD;
 343                       break;
 344                     case 23:
 345                       CU(o)->cu_TxFlags &= ~CON_TXTFLAGS_ITALIC;
 346                       break;
 347                     case 24:
 348                       CU(o)->cu_TxFlags &= ~CON_TXTFLAGS_UNDERLINED;
 349                       break;
 350                     case 27:
 351                       CU(o)->cu_TxFlags &= ~CON_TXTFLAGS_REVERSED;
 352                       break;
 353                     case 28:
 354                       CU(o)->cu_TxFlags &= ~CON_TXTFLAGS_CONCEALED;
 355                       break;
 356                     case 30:
 357                     case 31:
 358                     case 32:
 359                     case 33:
 360                     case 34:
 361                     case 35:
 362                     case 36:
 363                     case 37:
 364                       CU(o)->cu_FgPen = param - 30;
 365                       break;
 366                     case 39:
 367                       CU(o)->cu_FgPen = 1;
 368                       break;
 369
 370                     case 40:
 371                     case 41:
 372                     case 42:
 373                     case 43:
 374                     case 44:
 375                     case 45:
 376                     case 46:
 377                     case 47:
 378                       CU(o)->cu_BgPen = param - 40;
 379                       break;
 380
 381                     case 49:
 382                       CU(o)->cu_BgPen = 1;
 383                       break;
 384                     } /* switch(param) */
 385
 386                 } /* for(i = 0; i < msg->NumParams; i++) */
 387             }
 388             break;
 389
 390
 391         case C_SET_RAWEVENTS:
 392             D(bug("Set Raw Events\n"));
 393             {
 394                 UBYTE i, param;
 395
 396                 for(i = 0; i < msg->NumParams; i++)
 397                 {
 398                     param = msg->Params[i];
 399
 400                     if (param <= IECLASS_MAX)
 401                     {
 402                         SET_RAWEVENT(o, param);
 403                     }
 404
 405                 } /* for(i = 0; i < msg->NumParams; i++) */
 406             }
 407             break;
 408
 409         case C_RESET_RAWEVENTS:
 410             D(bug("Set Raw Events\n"));
 411             {
 412                 UBYTE i, param;
 413
 414                 for(i = 0; i < msg->NumParams; i++)
 415                 {
 416                     param = msg->Params[i];
 417
 418                     if (param <= IECLASS_MAX)
 419                     {
 420                         RESET_RAWEVENT(o, param);
 421                     }
 422
 423                 } /* for(i = 0; i < msg->NumParams; i++) */
 424             }
 425             break;
 426
 427     } /* switch (msg->Command) */
 428
 429     ReturnVoid("Console::DoCommand");
 430 }
 431
 432 /**********************************
 433 **  Console::GetDefaultParams()  **
 434 **********************************/
 435 static VOID console_getdefaultparams(Class *cl, Object *o, struct P_Console_GetDefaultParams *msg)
 436 {
 437     switch (msg->Command)
 438     {
 439         case C_INSERT_CHAR:
 440         case C_CURSOR_UP:
 441         case C_CURSOR_DOWN:
 442         case C_CURSOR_FORWARD:
 443         case C_CURSOR_BACKWARD:
 444         case C_CURSOR_NEXT_LINE:
 445         case C_CURSOR_PREV_LINE:
 446         case C_SET_TOP_OFFSET:
 447         case C_SET_PAGE_LENGTH:
 448             msg->Params[0] = 1;
 449             break;
 450         case C_CURSOR_POS:
 451             msg->Params[0] = YCCP + 1;
 452             msg->Params[1] = XCCP + 1;
 453             break;
 454
 455 /* FIXME: Autodocs state commands in between here, has params RKRM: Devs saye the do not */
 456         case C_CURSOR_HTAB:
 457         case C_DELETE_CHAR:
 458         case C_SCROLL_UP:
 459         case C_SCROLL_DOWN:
 460             msg->Params[0] = 1;
 461             break;
 462
 463         case C_CURSOR_TAB_CTRL:
 464             msg->Params[0] = 0; /* set tab */
 465             break;
 466
 467
 468         case C_CURSOR_BACKTAB:
 469             msg->Params[0] = 1;
 470             break;
 471
 472         case C_SELECT_GRAPHIC_RENDITION:
 473             /* don't do anything, as params may be in any order */
 474             break;
 475
 476         case C_SET_RAWEVENTS:
 477             /* don't do anything, as params may be in any order */
 478             break;
 479
 480         case C_RESET_RAWEVENTS:
 481             /* don't do anything, as params may be in any order */
 482             break;
 483
 484     } /* switch (msg->Command) */
 485
 486     return;
 487 }
 488
 489 /*******************************
 490 **  Console::NewWindowSize()  **
 491 *******************************/
 492 static VOID console_newwindowsize(Class *cl, Object *o, struct P_Console_NewWindowSize *msg)
 493 {
 494     struct ConUnit *unit;
 495     struct consoledata *data;
 496     struct Window *win;
 497
 498     data = INST_DATA(cl, o);
 499     unit = (struct ConUnit *)data;
 500
 501     win = unit->cu_Window;
 502
 503     unit->cu_XMax     = (win->Width  - win->BorderRight  - unit->cu_XROrigin) / unit->cu_XRSize - 1;
 504     unit->cu_YMax     = (win->Height - win->BorderBottom - unit->cu_YROrigin) / unit->cu_YRSize - 1;
 505
 506     unit->cu_XRExtant = unit->cu_XROrigin + (unit->cu_XRSize * (unit->cu_XMax + 1) - 1);
 507     unit->cu_YRExtant = unit->cu_YROrigin + (unit->cu_YRSize * (unit->cu_YMax + 1) - 1);
 508
 509     if (unit->cu_XCCP > unit->cu_XMax) unit->cu_XCCP = unit->cu_XMax;
 510     if (unit->cu_YCCP > unit->cu_YMax) unit->cu_YCCP = unit->cu_YMax;
 511
 512     unit->cu_XCP = unit->cu_XCCP;
 513     unit->cu_YCP = unit->cu_YCCP;
 514
 515     return;
 516 }
 517
 518
 519
 520 /********* Console class dispatcher **********************************/
 521 AROS_UFH3S(IPTR, dispatch_consoleclass,
 522     AROS_UFHA(Class *,  cl,  A0),
 523     AROS_UFHA(Object *, o,   A2),
 524     AROS_UFHA(Msg,      msg, A1)
 525 )
 526 {
 527     AROS_USERFUNC_INIT
 528
 529     IPTR retval = 0UL;
 530
 531     switch (msg->MethodID)
 532     {
 533     case OM_NEW:
 534         retval = (IPTR)console_new(cl, o, (struct opSet *)msg);
 535         break;
 536
 537     case M_Console_Left:
 538         console_left(cl, o, (struct P_Console_Left *)msg);
 539         break;
 540
 541     case M_Console_Right:
 542         console_right(cl, o, (struct P_Console_Right *)msg);
 543         break;
 544
 545     case M_Console_Up:
 546         console_up(cl, o, (struct P_Console_Up *)msg);
 547         break;
 548
 549     case M_Console_Down:
 550         console_down(cl, o, (struct P_Console_Down *)msg);
 551         break;
 552
 553     case M_Console_DoCommand:
 554         console_docommand(cl, o, (struct P_Console_DoCommand *)msg);
 555         break;
 556
 557     case M_Console_GetDefaultParams:
 558         console_getdefaultparams(cl, o, (struct P_Console_GetDefaultParams *)msg);
 559         break;
 560
 561     case M_Console_NewWindowSize:
 562         console_newwindowsize(cl, o, (struct P_Console_NewWindowSize *)msg);
 563         break;
 564
 565     default:
 566         retval = DoSuperMethodA(cl, o, msg);
 567         break;
 568
 569     }
 570     return (retval);
 571
 572     AROS_USERFUNC_EXIT
 573 }
 574
 575
 576 /************************
 577 **  normalizecoords()  **
 578 ************************/
 579
 580 /* Normalizes "out of window" coords, so that they
 581    fit into the window
 582 */
 583
 584 #define ABS(a) (((a) < 0) ? -(a) : (a))
 585
 586
 587 #undef ConsoleDevice
 588 #define ConsoleDevice ((struct ConsoleBase *)OCLASS(o)->cl_UserData)
 589
 590 /* FIXME: Currently dead code */
 591 VOID normalizecoords(Object *o, WORD *x_ptr, WORD *y_ptr)
 592 {
 593     EnterFunc(bug("normalizecoords(o=%p, x=%d, y=%d)\n",
 594         o, *x_ptr, *y_ptr));
 595
 596     if (*x_ptr > CU(o)->cu_XMax) /* charpos too far to the right */
 597     {
 598         D(bug("Pos right of window\n"));
 599         /* Increase y */
 600         Console_Down(o, *x_ptr / CHAR_XMAX(o) );
 601
 602         /* Normalize x */
 603         *x_ptr = *x_ptr % (CHAR_XMAX(o) - CHAR_XMIN(o));
 604     }
 605     else if (*x_ptr < CHAR_XMIN(o))
 606     {
 607         D(bug("Pos left of window\n"));
 608
 609         /* Decrease y */
 610         Console_Up(o, ABS(*x_ptr) / CHAR_XMAX(o) - CHAR_XMIN(o) );
 611
 612         /* Normalize Z */
 613         *x_ptr = *x_ptr % (CHAR_XMAX(o) - CHAR_XMIN(o));
 614
 615     }
 616
 617     if (*y_ptr > CHAR_YMAX(o))  /* pos below window bounds */
 618     {
 619
 620         *y_ptr = CHAR_YMAX(o);
 621     }
 622     else if (*y_ptr < CHAR_YMIN(o))
 623     {
 624         UBYTE scroll_param = CHAR_YMIN(o) - *y_ptr;     /* pos above window bounds */
 625
 626         D(bug("Pos above window\n"));
 627
 628         Console_DoCommand(o, C_SCROLL_DOWN, 1, &scroll_param);
 629
 630         *y_ptr = CHAR_YMIN(o);
 631
 632     }
 633
 634     ReturnVoid("normalizecoords");
 635
 636 }
 637
 638
 639 #undef ConsoleDevice
 640
 641 Class *makeConsoleClass(struct ConsoleBase *ConsoleDevice)
 642 {
 643
 644    Class *cl;
 645
 646    cl = MakeClass(NULL, ROOTCLASS, NULL, sizeof(struct consoledata), 0UL);
 647    if (cl)
 648    {
 649         cl->cl_Dispatcher.h_Entry = (APTR)dispatch_consoleclass;
 650         cl->cl_Dispatcher.h_SubEntry = NULL;
 651
 652         cl->cl_UserData = (IPTR)ConsoleDevice;
 653
 654         return (cl);
 655     }
 656     return (NULL);
 657 }
 658