src/gtx/dumbwindows.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * Description:
  12  *      Implementation of the gator dumb window facility.
  13  *
  14  *------------------------------------------------------------------------*/
  15
  16 #include <afsconfig.h>
  17 #include <afs/param.h>
  18
  19
  20 #include "gtxdumbwin.h"         /*Interface definition */
  21 #include <stdio.h>              /*Standard I/O package */
  22 #include <errno.h>
  23
  24 int dumb_debug;                 /*Is debugging turned on? */
  25 static char mn[] = "gator_dumbwindows"; /*Module name */
  26
  27 /*
  28  * Version of standard operations for a dumb window.
  29  */
  30 struct gwinops dumb_gwinops = {
  31     gator_dumbgwin_box,
  32     gator_dumbgwin_clear,
  33     gator_dumbgwin_destroy,
  34     gator_dumbgwin_display,
  35     gator_dumbgwin_drawline,
  36     gator_dumbgwin_drawrectangle,
  37     gator_dumbgwin_drawchar,
  38     gator_dumbgwin_drawstring,
  39     gator_dumbgwin_invert,
  40     gator_dumbgwin_getchar,
  41     gator_dumbgwin_getdimensions,
  42     gator_dumbgwin_wait,
  43 };
  44
  45 struct gwinbaseops gator_dumb_gwinbops = {
  46     gator_dumbgwin_create,
  47     gator_dumbgwin_cleanup
  48 };
  49
  50 /*
  51  * Macros to map pixel positions to row & column positions.
  52  * (Note: for now, they are the identity function!!)
  53  */
  54 #define GATOR_MAP_X_TO_COL(w, x)    (x)
  55 #define GATOR_MAP_Y_TO_LINE(w, y)   (y)
  56
  57 /*------------------------------------------------------------------------
  58  * gator_dumbgwin_init
  59  *
  60  * Description:
  61  *      Initialize the dumb window package.
  62  *
  63  * Arguments:
  64  *      int adebug: Is debugging turned on?
  65  *
  66  * Returns:
  67  *      0 on success,
  68  *      Error value otherwise.
  69  *
  70  * Environment:
  71  *      Nothing interesting.
  72  *
  73  * Side Effects:
  74  *      As advertised.
  75  *------------------------------------------------------------------------*/
  76
  77 int
  78 gator_dumbgwin_init(int adebug)
  79 {                               /*gator_dumbgwin_init */
  80
  81     static char rn[] = "gator_dumbgwin_init";   /*Routine name */
  82
  83     /*
  84      * Remember if we'll be doing debugging, init dumb and clear the
  85      * standard screen.
  86      */
  87     dumb_debug = adebug;
  88
  89     if (dumb_debug)
  90         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
  91
  92     /*
  93      * We always return success here.
  94      */
  95     return (0);
  96
  97 }                               /*gator_dumbgwin_init */
  98
  99 /*------------------------------------------------------------------------
 100  * gator_dumbgwin_create
 101  *
 102  * Description:
 103  *      Create a dumb window.
 104  *
 105  * Arguments:
 106  *      struct gator_dumbgwin_params *params : Ptr to creation parameters.
 107  *
 108  * Returns:
 109  *      Ptr to the created dumb window if successful,
 110  *      Null ptr otherwise.
 111  *
 112  * Environment:
 113  *      Nothing interesting.
 114  *
 115  * Side Effects:
 116  *      As advertised.
 117  *------------------------------------------------------------------------*/
 118
 119 struct gwin *
 120 gator_dumbgwin_create(void *rock)
 121 {                               /*gator_dumbgwin_create */
 122
 123     static char rn[] = "gator_dumbgwin_create"; /*Routine name */
 124     if (dumb_debug)
 125         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 126
 127     /*
 128      * Return failure here, fill this routine in at some point.
 129      */
 130     return (NULL);
 131
 132 }                               /*gator_dumbgwin_create */
 133
 134 /*------------------------------------------------------------------------
 135  * gator_dumbgwin_cleanup
 136  *
 137  * Description:
 138  *      Create a dumb window.
 139  *
 140  * Arguments:
 141  *      struct gwin *gwp : Ptr to base window.
 142  *
 143  * Returns:
 144  *      0 on success,
 145  *      Error value otherwise.
 146  *
 147  * Environment:
 148  *      Nothing interesting.
 149  *
 150  * Side Effects:
 151  *      As advertised.
 152  *------------------------------------------------------------------------*/
 153
 154 int
 155 gator_dumbgwin_cleanup(struct gwin *gwp)
 156 {                               /*gator_dumbgwin_cleanup */
 157
 158     static char rn[] = "gator_dumbgwin_cleanup";        /*Routine name */
 159
 160     if (dumb_debug)
 161         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 162
 163     /*
 164      * Return success here, fill this routine in at some point.
 165      */
 166     return (0);
 167
 168 }                               /*gator_dumbgwin_cleanup */
 169
 170 /*------------------------------------------------------------------------
 171  * gator_dumbgwin_box
 172  *
 173  * Description:
 174  *      Draw a box around the given dumb window.
 175  *
 176  * Arguments:
 177  *      struct gwin *gwp : Ptr to the dumb window to draw
 178  *                         a box around.
 179  *
 180  * Returns:
 181  *      0 on success,
 182  *      Error value otherwise.
 183  *
 184  * Environment:
 185  *      Nothing interesting.
 186  *
 187  * Side Effects:
 188  *      As advertised.
 189  *------------------------------------------------------------------------*/
 190
 191 int
 192 gator_dumbgwin_box(struct gwin *gwp)
 193 {                               /*gator_dumbgwin_box */
 194
 195     static char rn[] = "gator_dumbgwin_box";    /*Routine name */
 196
 197     if (dumb_debug)
 198         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 199
 200     /*
 201      * Return success here, fill in the routine at some point.
 202      */
 203     return (0);
 204
 205 }                               /*gator_dumbgwin_box */
 206
 207 /*------------------------------------------------------------------------
 208  * gator_dumbgwin_clear
 209  *
 210  * Description:
 211  *      Clear out the given dumb window.
 212  *
 213  * Arguments:
 214  *      struct gwin *gwp : Ptr to the dumb window to clear out.
 215  *
 216  * Returns:
 217  *      0 on success,
 218  *      Error value otherwise.
 219  *
 220  * Environment:
 221  *      Nothing interesting.
 222  *
 223  * Side Effects:
 224  *      As advertised.
 225  *------------------------------------------------------------------------*/
 226
 227 int
 228 gator_dumbgwin_clear(struct gwin *gwp)
 229 {                               /*gator_dumbgwin_clear */
 230
 231     static char rn[] = "gator_dumbgwin_clear";  /*Routine name */
 232
 233     if (dumb_debug)
 234         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 235
 236     /*
 237      * Return success, fill in this routine at some point.
 238      */
 239     return (0);
 240
 241 }                               /*gator_dumbgwin_clear */
 242
 243 /*------------------------------------------------------------------------
 244  * gator_dumbgwin_destroy
 245  *
 246  * Description:
 247  *      Destroy the given dumb window.
 248  *
 249  * Arguments:
 250  *      struct gwin *gwp : Ptr to the dumb window to destroy.
 251  *
 252  * Returns:
 253  *      0 on success,
 254  *      Error value otherwise.
 255  *
 256  * Environment:
 257  *      Nothing interesting.
 258  *
 259  * Side Effects:
 260  *      As advertised.
 261  *------------------------------------------------------------------------*/
 262
 263 int
 264 gator_dumbgwin_destroy(struct gwin *gwp)
 265 {                               /*gator_dumbgwin_destroy */
 266
 267     static char rn[] = "gator_dumbgwin_destroy";        /*Routine name */
 268
 269     if (dumb_debug)
 270         fprintf(stderr, "[%s:%s] Called", mn, rn);
 271
 272     return (0);
 273
 274 }                               /*gator_dumbgwin_destroy */
 275
 276 /*------------------------------------------------------------------------
 277  * gator_dumbgwin_display
 278  *
 279  * Description:
 280  *      Display/redraw the given dumb window.
 281  *
 282  * Arguments:
 283  *      struct gwin *gwp : Ptr to the dumb window to draw.
 284  *
 285  * Returns:
 286  *      0 on success,
 287  *      Error value otherwise.
 288  *
 289  * Environment:
 290  *      Nothing interesting.
 291  *
 292  * Side Effects:
 293  *      As advertised.
 294  *------------------------------------------------------------------------*/
 295
 296 int
 297 gator_dumbgwin_display(struct gwin *gwp)
 298 {                               /*gator_dumbgwin_display */
 299
 300     static char rn[] = "gator_dumbgwin_display";        /*Routine name */
 301
 302     if (dumb_debug)
 303         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 304
 305     /*
 306      * Return success, fill in this routine at some point.
 307      */
 308     return (0);
 309
 310 }                               /*gator_dumbgwin_display */
 311
 312 /*------------------------------------------------------------------------
 313  * gator_dumbgwin_drawline
 314  *
 315  * Description:
 316  *      Draw a line between two points in the given dumb
 317  *      window.
 318  *
 319  * Arguments:
 320  *      struct gwin *gwp : Ptr to the dumb window in which
 321  *                                 the line is to be drawn.
 322  *      struct gwin_lineparams *params : Ptr to other params.
 323  *
 324  * Returns:
 325  *      0 on success,
 326  *      Error value otherwise.
 327  *
 328  * Environment:
 329  *      Nothing interesting.
 330  *
 331  * Side Effects:
 332  *      As advertised.
 333  *------------------------------------------------------------------------*/
 334
 335 int
 336 gator_dumbgwin_drawline(struct gwin *gwp, struct gwin_lineparams *params)
 337 {                               /*gator_dumbgwin_drawline */
 338
 339     static char rn[] = "gator_dumbgwin_drawline";       /*Routine name */
 340
 341     if (dumb_debug)
 342         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 343                 rn);
 344
 345     /*
 346      * Return success, fill in this routine at some point.
 347      */
 348     return (0);
 349
 350 }                               /*gator_dumbgwin_drawline */
 351
 352 /*------------------------------------------------------------------------
 353  * gator_dumbgwin_drawrectangle
 354  *
 355  * Description:
 356  *      Draw a rectangle in the given dumb window.
 357  *
 358  * Arguments:
 359  *      struct gwin *gwp : Ptr to the dumb window in which
 360  *                                 the rectangle is to be drawn.
 361  *      struct gwin_rectparams *params : Ptr to other params.
 362  *
 363  * Returns:
 364  *      0 on success,
 365  *      Error value otherwise.
 366  *
 367  * Environment:
 368  *      Nothing interesting.
 369  *
 370  * Side Effects:
 371  *      As advertised.
 372  *------------------------------------------------------------------------*/
 373
 374 int
 375 gator_dumbgwin_drawrectangle(struct gwin *gwp, struct gwin_rectparams *params)
 376 {                               /*gator_dumbgwin_drawrectangle */
 377
 378     static char rn[] = "gator_dumbgwin_drawrectangle";  /*Routine name */
 379
 380     if (dumb_debug)
 381         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 382                 rn);
 383
 384     /*
 385      * Return success, fill in this routine at some point.
 386      */
 387     return (0);
 388
 389 }                               /*gator_dumbgwin_drawrectangle */
 390
 391 /*------------------------------------------------------------------------
 392  * gator_dumbgwin_drawchar
 393  *
 394  * Description:
 395  *      Draw a character in the given dumb window.
 396  *
 397  * Arguments:
 398  *      struct gwin *gwp : Ptr to the dumb window in which
 399  *                                 the character is to be drawn.
 400  *      struct gwin_charparams *params : Ptr to other params.
 401  *
 402  * Returns:
 403  *      0 on success,
 404  *      Error value otherwise.
 405  *
 406  * Environment:
 407  *      Nothing interesting.
 408  *
 409  * Side Effects:
 410  *      As advertised.
 411  *------------------------------------------------------------------------*/
 412
 413 int
 414 gator_dumbgwin_drawchar(struct gwin *gwp, struct gwin_charparams *params)
 415 {                               /*gator_dumbgwin_drawchar */
 416
 417     static char rn[] = "gator_dumbgwin_drawchar";       /*Routine name */
 418
 419     if (dumb_debug)
 420         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 421
 422     /*
 423      * Return success, fill in this routine at some point.
 424      */
 425     return (0);
 426
 427 }                               /*gator_dumbgwin_drawchar */
 428
 429 /*------------------------------------------------------------------------
 430  * gator_dumbgwin_drawstring
 431  *
 432  * Description:
 433  *      Draw a string in the given dumb window.
 434  *
 435  * Arguments:
 436  *      struct gwin *gwp : Ptr to the dumb window in which
 437  *                                 the string is to be drawn.
 438  *      struct gwin_strparams *params : Ptr to other params.
 439  *
 440  * Returns:
 441  *      0 on success,
 442  *      Error value otherwise.
 443  *
 444  * Environment:
 445  *      Nothing interesting.
 446  *
 447  * Side Effects:
 448  *      As advertised.
 449  *------------------------------------------------------------------------*/
 450
 451 int
 452 gator_dumbgwin_drawstring(struct gwin *gwp, struct gwin_strparams *params)
 453 {                               /*gator_dumbgwin_drawstring */
 454
 455     static char rn[] = "gator_dumbgwin_drawstring";     /*Routine name */
 456
 457     if (dumb_debug)
 458         fprintf(stderr, "[%s:%s] Called\n", mn, rn);
 459
 460     /*
 461      * Return success, fill in this routine at some point.
 462      */
 463     return (0);
 464
 465 }                               /*gator_dumbgwin_drawstring */
 466
 467 /*------------------------------------------------------------------------
 468  * gator_dumbgwin_invert
 469  *
 470  * Description:
 471  *      Invert a region in the given dumb window.
 472  *
 473  * Arguments:
 474  *      struct gwin *gwp : Ptr to the dumb window in which
 475  *                                 the inverted region lies.
 476  *      struct gwin_invparams *params : Ptr to other params.
 477  *
 478  * Returns:
 479  *      0 on success,
 480  *      Error value otherwise.
 481  *
 482  * Environment:
 483  *      Nothing interesting.
 484  *
 485  * Side Effects:
 486  *      As advertised.
 487  *------------------------------------------------------------------------*/
 488
 489 int
 490 gator_dumbgwin_invert(struct gwin *gwp, struct gwin_invparams *params)
 491 {                               /*gator_dumbgwin_invert */
 492
 493     static char rn[] = "gator_dumbgwin_invert"; /*Routine name */
 494
 495     if (dumb_debug)
 496         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 497                 rn);
 498
 499     /*
 500      * Return success, fill in this routine at some point.
 501      */
 502     return (0);
 503
 504 }                               /*gator_dumbgwin_invert */
 505
 506 /*------------------------------------------------------------------------
 507  * gator_dumbgwin_getchar
 508  *
 509  * Description:
 510  *      Pick up a character from the given window.
 511  *
 512  * Arguments:
 513  *      struct gwin *gwp : Ptr to the dumb window to listen to.
 514  *
 515  * Returns:
 516  *      Value of the character read,
 517  *      -1 otherwise.
 518  *
 519  * Environment:
 520  *      Nothing interesting.
 521  *
 522  * Side Effects:
 523  *      As advertised.
 524  *------------------------------------------------------------------------*/
 525
 526 int
 527 gator_dumbgwin_getchar(struct gwin *gwp)
 528 {                               /*gator_dumbgwin_getchar */
 529
 530     static char rn[] = "gator_dumbgwin_getchar";        /*Routine name */
 531
 532     if (dumb_debug)
 533         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 534                 rn);
 535
 536     return (-1);
 537
 538 }                               /*gator_dumbgwin_getchar */
 539
 540 /*------------------------------------------------------------------------
 541  * gator_dumbgwin_getdimensions
 542  *
 543  * Description:
 544  *      Get the window's X,Y dimensions.
 545  *
 546  * Arguments:
 547  *      struct gwin *gwp               : Ptr to the dumb window to examine.
 548  *      struct gwin_sizeparams *aparms : Ptr to size params to set.
 549  *
 550  * Returns:
 551  *      0 if successful,
 552  *      -1 otherwise.
 553  *
 554  * Environment:
 555  *      Nothing interesting.
 556  *
 557  * Side Effects:
 558  *      As advertised.
 559  *------------------------------------------------------------------------*/
 560
 561 int
 562 gator_dumbgwin_getdimensions(struct gwin *gwp, struct gwin_sizeparams *aparms)
 563 {                               /*gator_dumbgwin_getdimensions */
 564
 565     static char rn[] = "gator_dumbgwin_getdimensions";  /*Routine name */
 566
 567     if (dumb_debug)
 568         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 569                 rn);
 570
 571     return (-1);
 572
 573 }                               /*gator_dumbgwin_getdimensions */
 574
 575 /*------------------------------------------------------------------------
 576  * gator_dumbgwin_wait
 577  *
 578  * Description:
 579  *      Wait until input is available.
 580  *
 581  * Arguments:
 582  *      struct gwin *gwp : Ptr to the dumb window to wait on.
 583  *
 584  * Returns:
 585  *      0 if successful,
 586  *      -1 otherwise.
 587  *
 588  * Environment:
 589  *      Nothing interesting.
 590  *
 591  * Side Effects:
 592  *      As advertised.
 593  *------------------------------------------------------------------------*/
 594
 595 int
 596 gator_dumbgwin_wait(struct gwin *gwp)
 597 {                               /*gator_dumbgwin_wait */
 598
 599     static char rn[] = "gator_dumbgwin_wait";   /*Routine name */
 600
 601     if (dumb_debug)
 602         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 603                 rn);
 604
 605     return (-1);
 606
 607 }                               /*gator_dumbgwin_wait */