cde/programs/dtterm/tests/shared/esclib.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: esclib.c /main/3 1995/10/31 12:00:21 rswiston $ */
  24 #include <stdio.h>
  25 #include "escbase.h"
  26 #include "common.h"
  27
  28 extern char *READTEST();
  29
  30 #define  ESC_STR_LEN      20
  31
  32 void HomeUp()
  33 {
  34     WRITETEST(HOME_UP);
  35 }
  36
  37 void ClearScreen()
  38 {
  39   char Str[ESC_STR_LEN];
  40     sprintf(Str, "%s%s", HOME_UP, CLEAR_DISP);
  41     WRITETEST(Str);
  42 }
  43
  44 void CursorUp(HowMuch)
  45 int HowMuch;
  46 {
  47   char Str[10];
  48    if (HowMuch == 0) return;
  49    sprintf(Str, CURSOR_N_UP, HowMuch);
  50    WRITETEST(Str);
  51 }
  52
  53 void CursorDown(HowMuch)
  54 int HowMuch;
  55 {
  56   char Str[10];
  57    if (HowMuch == 0) return;
  58    sprintf(Str, CURSOR_N_DOWN, HowMuch);
  59    WRITETEST(Str);
  60 }
  61
  62 void CursorForward(HowMuch)
  63 int HowMuch;
  64 {
  65   char Str[10];
  66    if (HowMuch == 0) return;
  67    sprintf(Str, CURSOR_N_FORW, HowMuch);
  68    WRITETEST(Str);
  69 }
  70
  71 void CursorBack(HowMuch)
  72 int HowMuch;
  73 {
  74   char Str[10];
  75    if (HowMuch == 0) return;
  76    sprintf(Str, CURSOR_N_BACK, HowMuch);
  77    WRITETEST(Str);
  78 }
  79
  80 void CursorPrevLine(HowMuch)
  81 int HowMuch;
  82 {
  83   char Str[10];
  84    if (HowMuch == 0) return;
  85    sprintf(Str, CURSOR_N_PREV_LINE, HowMuch);
  86    WRITETEST(Str);
  87 }
  88
  89 void CursorColumn(HowMuch)
  90 int HowMuch;
  91 {
  92   char Str[10];
  93    if (HowMuch == 0) return;
  94    sprintf(Str, CURSOR_N_COLUMN, HowMuch);
  95    WRITETEST(Str);
  96 }
  97
  98 void GetCursorPosn(X, Y)
  99 int *X, *Y;
 100     /* expected ESC sequence is of the form Esc[n1;n2R */
 101 {
 102   char  *Ptr, Line[5], Col[5];
 103   int i, j;
 104     WRITETEST(CUR_POSN_STAT);
 105     Ptr = READTEST("R");
 106     i = 2; j = 0;
 107     while (Ptr[i] != ';') {Line[j] = Ptr[i]; i++; j++;}
 108     Line[j++] = NULLCHAR;
 109     i++; j = 0;
 110     while (Ptr[i] != 'R') {Col[j] = Ptr[i]; i++; j++;}
 111     Col[j++] = NULLCHAR;
 112     *Y = atoi(Line); *X = atoi(Col);
 113 }
 114
 115 int CheckTermStatus()
 116     /* return 1 if term is in proper status else 0 */
 117 {
 118   char  *Ptr;
 119     WRITETEST(TERMINAL_STAT);
 120     Ptr = READTEST("n");
 121     if (strcmp(Ptr, TERMINAL_GOOD) == 0) return(0);
 122     else return(-1);
 123 }
 124
 125 void AbsoluteGoToXY(X, Y)
 126 int X, Y;
 127 {
 128   char Str[ESC_STR_LEN];
 129     sprintf(Str, GOTO_X_Y, Y, X);
 130     WRITETEST(Str);
 131 }
 132
 133 void AbsoluteGoToXY_HVP(X, Y)
 134 int X, Y;
 135 {
 136   char Str[ESC_STR_LEN];
 137     sprintf(Str, GOTO_X_Y_HVP, Y, X);
 138     WRITETEST(Str);
 139 }
 140
 141 void RelativeGoToXY(CurrX, CurrY, X, Y)
 142 int CurrX, CurrY, X, Y;
 143 {
 144     if (X < CurrX) CursorBack((CurrX - X));
 145     else CursorForward((X - CurrX));
 146     if (Y < CurrY) CursorUp((CurrY - Y));
 147     else CursorDown((Y - CurrY));
 148 }
 149
 150 void Index()
 151 {
 152     WRITETEST(INDEX);
 153 }
 154
 155
 156 void ReverseIndex()
 157 {
 158     WRITETEST(REVERSEINDEX);
 159 }
 160
 161
 162 void NextLine()
 163 {
 164     WRITETEST(NEXTLINE);
 165 }
 166
 167 void InsertLines(Howmany)
 168 int Howmany;
 169 {
 170   char Str[10];
 171    if (Howmany == 0) return;
 172    sprintf(Str, INSERT_N_LINE, Howmany);
 173    WRITETEST(Str);
 174 }
 175
 176 void InsertBlanks(Howmany)
 177 int Howmany;
 178 {
 179   char Str[10];
 180    if (Howmany == 0) return;
 181    sprintf(Str, INSERT_N_BLANK, Howmany);
 182    WRITETEST(Str);
 183 }
 184
 185 void DeleteLines(Howmany)
 186 int Howmany;
 187 {
 188   char Str[10];
 189    if (Howmany == 0) return;
 190    sprintf(Str, DELETE_N_LINE, Howmany);
 191    WRITETEST(Str);
 192 }
 193
 194
 195 void DeleteChars(Howmany)
 196 int Howmany;
 197 {
 198   char Str[10];
 199    if (Howmany == 0) return;
 200    sprintf(Str, DELETE_N_CHAR, Howmany);
 201    WRITETEST(Str);
 202 }
 203
 204 void SetInsertMode()
 205 {
 206     WRITETEST(INSERT_MODE);
 207 }
 208
 209
 210 void SetReplaceMode()
 211 {
 212     WRITETEST(REPLACE_MODE);
 213 }
 214
 215 void GetWinSize(Lines, Cols)
 216 int *Lines, *Cols;
 217 {
 218     AbsoluteGoToXY(999, 999);
 219     GetCursorPosn(Cols, Lines);
 220 }
 221
 222 /*** TabFunctions  ***/
 223
 224 void ClearAllTabs()
 225 {
 226     WRITETEST(CLEAR_ALL_TABS);
 227 }
 228
 229 void ClearCurTab()
 230 {
 231     WRITETEST(CLEAR_CUR_TAB);
 232 }
 233
 234 void SetTab()
 235 {
 236     WRITETEST(SET_TAB);
 237 }
 238
 239
 240 void EraseLnFromCur()
 241 {
 242     WRITETEST(ERASE_LN_FROM_CUR);
 243 }
 244
 245
 246 void EraseLnToCur()
 247 {
 248     WRITETEST(ERASE_LN_TO_CUR);
 249 }
 250
 251 void EraseLnAll()
 252 {
 253     WRITETEST(ERASE_LN_ALL);
 254 }
 255
 256
 257 void EraseScrFromCur()
 258 {
 259     WRITETEST(ERASE_FROM_CUR);
 260 }
 261
 262
 263 void EraseScrToCur()
 264 {
 265     WRITETEST(ERASE_TO_CUR);
 266 }
 267
 268 void EraseScrAll()
 269 {
 270     WRITETEST(ERASE_ALL);
 271 }
 272
 273 void EraseChars(Howmany)
 274 int Howmany;
 275 {
 276   char Str[10];
 277    if (Howmany == 0) return;
 278    sprintf(Str, ERASE_N_CHAR, Howmany);
 279    WRITETEST(Str);
 280 }
 281
 282
 283 void SetApplnKeyPad()
 284 {
 285     WRITETEST(APPLN_KEYPAD);
 286 }
 287
 288 void SetNormalKeyPad()
 289 {
 290     WRITETEST(NORMAL_KEYPAD);
 291 }
 292
 293 void SetDispNormal()
 294 {
 295     WRITETEST(NORMAL);
 296 }
 297
 298 void SetDispBold()
 299 {
 300     WRITETEST(BOLD);
 301 }
 302
 303 void SetDispUnderscore()
 304 {
 305     WRITETEST(UNDERSCORE);
 306 }
 307
 308 void SetDispBlink()
 309 {
 310     WRITETEST(BLINK);
 311 }
 312
 313 void SetDispInverse()
 314 {
 315     WRITETEST(INVERSE);
 316 }
 317
 318 void SaveCursor()
 319 {
 320     WRITETEST(SAVE_CURSOR);
 321 }
 322
 323
 324 void RestoreCursor()
 325 {
 326     WRITETEST(RESTORE_CURSOR);
 327 }
 328
 329 void SetScrollRegn(Top, Bottom)
 330 int Top, Bottom;
 331 {
 332   char Str[ESC_STR_LEN];
 333     sprintf(Str, SET_SCROLL_REGN, Top, Bottom);
 334     WRITETEST(Str);
 335 }
 336
 337
 338 void SetCursorKeys(DECMode)
 339 DECModeType DECMode;
 340 {
 341     switch(DECMode) {
 342       case DECModeSet:
 343         WRITETEST(APPL_CUR_KEYS); break;
 344       case DECModeReset:
 345         WRITETEST(NORMAL_CUR_KEYS); break;
 346       case DECModeSave:
 347         WRITETEST(SAVE_CUR_KEYS); break;
 348       case DECModeRestore:
 349         WRITETEST(REST_CUR_KEYS); break;
 350     }
 351 }
 352
 353 void SetColumnWidth(DECMode)
 354 DECModeType DECMode;
 355 {
 356     switch(DECMode) {
 357       case DECModeSet:
 358         WRITETEST(COLUMN_80); break;
 359       case DECModeReset:
 360         WRITETEST(COLUMN_132); break;
 361       case DECModeSave:
 362         WRITETEST(SAVE_COLUMN_TYPE); break;
 363       case DECModeRestore:
 364         WRITETEST(REST_COLUMN_TYPE); break;
 365     }
 366 }
 367
 368 void SetScrollType(DECMode)
 369 DECModeType DECMode;
 370 {
 371     switch(DECMode) {
 372       case DECModeSet:
 373         WRITETEST(SMOOTH_SCROLL); break;
 374       case DECModeReset:
 375         WRITETEST(JUMP_SCROLL); break;
 376       case DECModeSave:
 377         WRITETEST(SAVE_SCROLL_TYPE); break;
 378       case DECModeRestore:
 379         WRITETEST(REST_SCROLL_TYPE); break;
 380     }
 381 }
 382
 383 void SetVideoType(DECMode)
 384 DECModeType DECMode;
 385 {
 386     switch(DECMode) {
 387       case DECModeSet:
 388         WRITETEST(REVERSE_VIDEO); break;
 389       case DECModeReset:
 390         WRITETEST(NORMAL_VIDEO); break;
 391       case DECModeSave:
 392         WRITETEST(SAVE_VIDEO_TYPE); break;
 393       case DECModeRestore:
 394         WRITETEST(REST_VIDEO_TYPE); break;
 395     }
 396 }
 397
 398 void SetOriginMode(DECMode)
 399 DECModeType DECMode;
 400 {
 401     switch(DECMode) {
 402       case DECModeSet:
 403         WRITETEST(ORIGIN_MODE); break;
 404       case DECModeReset:
 405         WRITETEST(CURSOR_MODE); break;
 406       case DECModeSave:
 407         WRITETEST(SAVE_SCREEN_MODE); break;
 408       case DECModeRestore:
 409         WRITETEST(REST_SCREEN_MODE); break;
 410     }
 411 }
 412
 413 void SetWrapMode(DECMode)
 414 DECModeType DECMode;
 415 {
 416     switch(DECMode) {
 417       case DECModeSet:
 418         WRITETEST(WRAP_MODE); break;
 419       case DECModeReset:
 420         WRITETEST(NO_WRAP_MODE); break;
 421       case DECModeSave:
 422         WRITETEST(SAVE_WRAP_MODE); break;
 423       case DECModeRestore:
 424         WRITETEST(REST_WRAP_MODE); break;
 425     }
 426 }
 427
 428 void SetMarginBell(DECMode)
 429 DECModeType DECMode;
 430 {
 431     switch(DECMode) {
 432       case DECModeSet:
 433         WRITETEST(MARGIN_BELL); break;
 434       case DECModeReset:
 435         WRITETEST(NO_MARGIN_BELL); break;
 436       case DECModeSave:
 437         WRITETEST(SAVE_MARGIN_BELL_TYPE); break;
 438       case DECModeRestore:
 439         WRITETEST(REST_MARGIN_BELL_TYPE); break;
 440     }
 441 }
 442
 443 void SetReverseWrap(DECMode)
 444 DECModeType DECMode;
 445 {
 446     switch(DECMode) {
 447       case DECModeSet:
 448         WRITETEST(REVERSE_WRAP); break;
 449       case DECModeReset:
 450         WRITETEST(NO_REVERSE_WRAP); break;
 451       case DECModeSave:
 452         WRITETEST(SAVE_REVERSE_WRAP_TYPE); break;
 453       case DECModeRestore:
 454         WRITETEST(REST_REVERSE_WRAP_TYPE); break;
 455     }
 456 }
 457
 458 void SetLoggingMode(DECMode)
 459 DECModeType DECMode;
 460 {
 461     switch(DECMode) {
 462       case DECModeSet:
 463         WRITETEST(START_LOGGING); break;
 464       case DECModeReset:
 465         WRITETEST(STOP_LOGGING); break;
 466       case DECModeSave:
 467         WRITETEST(SAVE_LOGGING_TYPE); break;
 468       case DECModeRestore:
 469         WRITETEST(REST_LOGGING_TYPE); break;
 470     }
 471 }
 472
 473 #define  BACKSPACE        010
 474
 475 void BackSpace(HowMany)
 476 int HowMany;
 477 {
 478   int i; char Str[20];
 479     for (i=0; i < HowMany-1; i++)
 480       {sprintf(Str, "%c", BACKSPACE); WRITETEST(Str);}
 481 }