
     .    .    " OS/2 "                  3



  *     ࠭
  *    
  * ࠢ ஬
  * ⥭  ࠭
  * ஫
  * ⥭ ᨬ  
  * ०


    묨 ன⢠ /뢮 ᮭ쭮 
 ࠭  .       ।稬 
 ᬮ७  API 㭪権  OS/2, 㦨   ன⢠. 
㭪樨  쭮  ਬ⨢:       ப  ࠭ 
뢠  ᨬ     ,             設⢠
ணࠬ⮢.    ⮬  롮  ⮣ ⢠ API 㭪権
㤥  㤠  砫    襬  ᫥  OS/2.    㤥   
ᯮ짮   쭥襬,   室 祭 㣨 API 㭪権.

     楫 ⮩  - ᯥ    
  API 㭪権,    㤥 ६  㧭     
࠭.    ஡   ⮭  ࠡ   ᯫ   㧭 
 13.

   砫 㤨 /뢮   ࠭,     ஫
   ࠭. ⥬ ६⨬      
ᬮਬ ⮤ 뢠 ᨬ    㣨    .
       㤥   饭  ।   ﭨ
, אַ 뢠   ࠭  ஡ ।
 ⠭ ०,  ⠪ । ࠬ஢ ᯫ.

   ᫨ ணࠬ ࠡ⠥  Presentation Manager, 맮 API 㭪権,
ᠭ  ⮩ , ࠡ 筮 ⠪,  ⮬ 室  ⮪
ࠢ,   ࠢ,   ,       ࠭.  ⠫
⭮襭    ⢥.  ணࠬ, 믮騥 API
㭪樨,    砥 ணࠬ, 㭪樮騬 
  ।,        ᮢ襭    ᯮᮡ
맮 ணࠬ.

                      .
		    _______________
   OS/2   ਡ⥫쭮  㭪権 ࠡ  ࠭.
  ࠧ  ᬮਬ   .

     楫ᮮࠧ   ᯮ짮  API   㭪,  祬   㭪
⥪ , ⠪  , ਬ, printf()  ?  API  㭪樨 
㭪ﬨ  ஢ 㤮묨   ᮡ ,  
  ⥬ ⢮ ⥩, ஥ 뢠  
printf(). ᭮  २⢮ API  㭪権 -  ᪮,  ॥
祬    ⥪ . API 㭪樨 ⠪  ࠡ
 筮 ०,  樨        
࠭ ६. ணࠬ  ᥬ   ᯮ짮 
⢥    ࣠樨 /뢮.  ணࠬ
   ࠢ 롮  ᨬ  ⥫.

   筮,  ᯮ짮  API  㭪権     ணࠬ 
設ᨬ,  ⠪    API  㭪樨  ᯮ ⮫쪮  ।
OS/2. ,  ணࠬ, ⠭   ०  ࠡ
  뢠騥  㣨  ᮡ  OS/2, ७ᨬ  
⥬.

       ⫨稥 楤 ⥪   API 㭪権,
ᠭ  ⮩ : API 㭪樨   ७ ன⢠,
  ᫨     ன⢠  ᢮  ⥬,
   ਪ ணࠬ,     ,  
ᯮ짮  ⮫쪮  㭪樨  ⥪  .   (  쪮
᪫祭    -            ७ࠢ    室    ⮪
䠩-ਥ஢ API  㭪樨 DosWrite(),      -  
ᬮਬ  , 饭 䠩.

	    .
	________________________________

     㭪樥  ਪ  䥩(API)  -   㭪
VioWrtCharStrAttr(),    ᨬ    ࠭.    㭪 
ப ᨬ         ࠭.

    ⠪  ਡ ப,  ⠪ 뢠 ᨬ
襭 મ, , 梥   ન.

    -   ਬ  ணࠬ,     ⠥   ப,   
짮⥫   ⠭⭮  㭪樨 gets(),   
   ⥬ ᯮ  VioWrtCharStrAttr()   ᢥ稢 ⮩
ப   業 ࠭.   ⪮  ࠧ 뢮   ॢᨢ
ࠦ.
/* viowrt.c */
/*  ᯮ짮 㭪樨 VioWrtCharStrAttr() */
#define INCL_DOS
#include <os2.h>
#include <stdio.h>
#include <string.h>
#define LENGTH 81    /*   ப             */
#define HANDLE  0    /* Handle  vio ᥣ ࠢ 0   */
main()
{
  char buffer[LENGTH];            /*   ப        */
  unsigned length;                /*  ப            */
  unsigned char attr = 0x70;      /* ਡ ॢ ப */
  unsigned row = 12;              /* ⠭ ப  N 12  */
  unsigned column = 0;            /* ⠭ 0- ⮫  */
  gets(buffer);                   /* 祭 ப        */
  length = strlen(buffer);        /* ᫥  ப */
  VioWrtCharStrAttr(buffer,length,row,column,&attr,HANDLE);

  exit(0);
}

    ࠭  ।  믮  ணࠬ.  ⮫쪮 ணࠬ
筥 ࠡ,     ᮮ饭      80 ᨬ  
稢饥 ⨥   [Enter].     祭   
  ࠭      ᮮ饭,    ᥣ 㤥  
ப 12.

    VioWrtCharStrAttr() -  뢮  ப  ᨬ
Ŀ
 VioWrtCharStrAttr(String,Length,Row,Column,AAttr,Handle);      
 unsigned char far *String;      /*  ப            */  
 unsigned Length;                /*  ப            */  
 char far AAttr;                 /*   ਡ⮢   */  
 unsigned Row = 12;              /* ⠭ ப  N 12  */  
 unsigned Column;                /* ⠭ 0- ⮫  */  
 unsigned short Handle;          /* Handle ᥣ ࠢ 0   */  



    VioWrtCharStrAttr()   㭪   ,   ᫨      뢮  
䨪஢   ࠭.   ਬ,     ᯮ짮
  ᮧ ࠭ .

    ६  String  ᮤন    ,  ᮤঠ饣  ப,
Length  -  ⮩ ப, Row  olumn - 㪠뢠   ࠭.
⬥⨬,    ⮩  㭪樨 (        㣨 VIO  㭪)
㬥   ⮫   0.

Ŀ
  栭            襭                                
                     ⥭ᨢ                             
        梥   䮭        梥 ᨬ                       
  Ŀ                     
    7   6   5   4   3   2   1   0                      
                       
                                
       0 0 0                     0 0 0   襭 ࠭         
       0 0 0                     0 0 1   ન          
       0 0 0                     1 1 1   ଠ ਡ    
       1 1 1                     0 0 0   ॢ஢         
       x x x                     x x x    梥⮢         

  . 3-1.  ਡ⮢.

     ਡ⮢(६ Attr) । ਡ  ப,
뤠  ࠭.   ਡ⮢(    ⥬,
ᮢ⨬  IBM),   .  3-1.

    祭  梥⮢   䮭:

         祭 
         -------------
         0        
         1        ᨭ
         2        
         3        樠
         4        
         5        
         6        筥
         7        

     ணࠬ viowrt.c  ᯮ㥬 ॢᨢ ०, ⠪  
ਡ⮢- 70  16 -  ଥ. ( - ୮   - 07).  
  ⮩         ਬ   ணࠬ,     
ᯥਬ஢   ਡ⠬  梥⭮  ஬ ०.

    ⨬    ६  Handle.   ࠬ, 騩 
-   API -  㭪権,  OS/2 ᥣ   祭 0.
 ᯥ稢 㢥祭 ⥩ OS/2  饬   
ଠ 맮 API - 㭪権.

    㣨 API  - 㭪樨  室   VioWrtCharStrAtt().  㭪,
VioWrtCharStr(),   ப    ਡ,   ᬮਬ
 ਬ  . 㣠  㭪, VioWrtCellStr(),   ப 
権 ᨬ -  ਡ⮢, ࠧ ᯮ짮   
ਡ   ப.

    VioWrtCharStrAtt()    㭪樨  室 ப   ,
  㣮.  ,  ⮫쪮  㭪 ⠥   ࠭, 
稢 ᨬ  ⮣,    ᨬ     .
  ப稢 ࠭    ⥫ ᨬ.

         ,     㭪樨  VioWrtCharStrAtt()    
⪨.  - ,   ᯮ ᯥ樠 ᨬ, ⠪,
  ⠡      ப.      ⠥  뢥 
ᨬ,      ᮮ⢥騥  ᪨ ᨬ  
⢨. 㣠 ஡  ⮬,   㭪樨  ६  
 뢮,  printf()   㣨 㭪樨 .  ࠧ,  ᫨ 
ᯮ    㭪    ࠪ⨢    - 뢮, 
ணࠬ  ⠥  ᪠     ⢥  짮⥫,   室
६    ᫥騬  蠣  (  ᬮਬ,   ᤥ
).

      㣠  API  -  㭪  蠥     ஡  
 ।⥩.  ᬮ   쭥襬.

         뢮   .

    㭪  VioWrtTTy()  㫨  ⢨      ࠭.  
稭    ⠬,    室  ,  ⠢  
 ப ᫥ 砭 .

      ணࠬ,    ᯮ    㭪    ⪮
⢨  짮⥫.

/* tty.c */
/*   ࠭  ⥫⠩ ० */
#define INCL_SUB
#include <os2.h>
#include <stdio.h>   /*  gets() */
#include <string.h>  /*  strlen() */
#define LENGTH 80    /*   */
#define HANDLE 0     /* ᥣ 0 */

char s1[] = ": ";         /* ᪠ */
char s2[] = ": ";
char s3[] = "਩ ";

main()
{
  char name[LENGTH];  /*   짮⥫᪮  */
  char rank[LENGTH];
  char serial[LENGTH];

VioWrtTTy(s1, strlen(s1), HANDLE); /*  1 -  ᪠ */

gets(name); /*   짮⥫ */

VioWrtTTy(s2, strlen(s2), HANDLE); /*  2 -  ᪠ */

gets(rank); /*  ࠭ 짮⥫ */

VioWrtTTy(s3, strlen(s3), HANDLE); /*  3 -  ᪠ */

gets(serial); /*  ਩  짮⥫ */

exit(0);
}

      ணࠬ  ⠥  ᪠,   ⢥ 짮⥫,
⠥ ᫥ ᪠,  ..  ਬ ࠡ:

:  
: 
਩ : 102947289

⨬,       㭪樨  VioWrtTTy() ப   ⮫;  
⢥ 砫쭮 窨   ᯮ ,  ६頥   
뢮,  ⠪        㤥  筮   ⠭     ᫥騩
짮⥫᪨ .

 VioWrtTTy() - ⠥ ப  ⥫⠩ ०
Ŀ
VioWrtTTy(String, Length, Handle);                          
char far *String;      /*  ⠥ ப */        
unsigned Length;       /*  ப */                   
unsigned short Handle; /*  ᥣ 0 */                 

      ,    ᫨       ஢  ᪠   
ணࠬ,  㭪  VioWrtTTy()  믮  ॢ  ࠢ
ᨬ.   ⠡㫨   ᨬ ⠡樨,   ᨣ,  
 ᨬ  "", 믮   ⪨,  ॢ ப  
    ᮮ⢥⢨   祭묨  ᨬ. 㣨  VIO -
㭪樨, ,  ᪨ ᨬ    ࠢ.
㭪  VioWrtTTy()  ஬  ⮣,    ⫨稥    㭪権,  
VioWrtCharStrAtt(),  ப稢  ࠭  ,  ᫨     稫
  諠   ࠭. VioWrtTTy()  ⠪ ᯮ짮
ESC - ᫥⥫쭮 ANSY.

      믮    㭪権, VioWrtTTy() ᬠਢ
 VIO - 㭪 ᮪ ஢,  ⫨稥  㣨 VIO -  㭪権,
  ஢.

          뢮  ᨬ.

      樨,  ⥫쭮   ࠧ    ᨬ.
  ⮩  楫    OS/2    ᪮쪮 㭪権.  ᬮਬ ,
       頤   ࠭      묨
⠬.    -  2-⭠   祩,   ᮤঠ  ᨬ 
ਡ.

     ணࠬ ਬ ⠥  ப  2000 ⮢,  
   ࠭ 묨  ᨬ. ணࠬ   
 ᨬ,  ᯮ㥬    ࠭,   ਡ.  
    몫  , મ,     몫
⨢, , ᫨   梥⭮  ᯫ, -  梥    䮭
ᨬ. 롮   ᤥ ணࠬ ᪠. 室 -  
 [ESC].

/* attr.c */
/* 뢮 ࠧ ਡ  ࠭ */
#define INCL_SUB
#include <os2.h>
#define TRUE 1
#define HANDLE 0        /*  ᥣ 0 */
#define FOREGROUND 0x07 /* ᪠   */
#define BACKGROUND 0x70 /* ᪠  䮭 */
#define INTENSITY 0x08  /* ᪠  ⥭ᨢ */
#define BLINKING 0x80   /* ᪠  栭 */
#define UNDERLINE 0x01  /* 祭  ન */
main()
{
  char command_letter;   /* ⠥ 짮⥫ */
  unsigned char cell[2]; /*  ᨬ - ਡ */
  unsigned color;        /*  梥 */

  printf(" 'n'  ଠ쭮, 'u'  ન,\n");
  printf("        'i'  મ, 'b'  栭,\n");
  printf("        'r'  ॢ ⨢.");
  printf(" +n   梥 ,\n");
  printf("        -n   梥 䮭,\n");
  printf("         'n' - 祭  0  7");

  cell[0] = 'x';    /*  ᨬ */
  cell[1] = 0x07;   /* ଠ ਡ */
                 /* ⥭  㪢, 室   [ESC] */
  while( (command_letter=getche()) != 27) {
    switch(command_letter) {
    case 'n':                   /* ଠ */
       cell[1] != FOREGROUND;   /*  . */
       cell[1] &= ~BACKGROUND;  /* 䮭 몫. */
       break;
    case 'u':                   /* ન */
       cell[1] &= ~FOREGROUND;  /*  = 1 */
       cell[1] != UNDERLINE;
       break;
    case 'i':                   /* ⥭ᨢ */
       cell[1] ^= INTENSITY;    /*  ⥭ᨢ */
       break;
    case 'b':                   /* ⥭ᨢ */
       cell[1] ^= BLINKING;     /*  ⥭ᨢ */
       break;
    case 'r':                   /* ॢ */
       cell[1] &= ~FOREGROUND;  /*  몫. */
       cell[1] != BACKGROUND;   /* 䮭 몫. */
       break;
    case '+':                   /* 梥  */
       cell[1] &= ~FOREGROUND;  /* 뢮   */
       cell[1] != getche() - 0x30;
       break;
    case '-':                   /* 梥 䮭 */
       cell[1] &= ~BACKGROUND;  /* 뢮  䮭 */
       cell[1] != (getche() - 0x30) << 4;
       break;
    default:                     /* ᫨  , */
       cell[0] = command_letter; /*  ᨬ   */
    }
    VioWrtNCell( (char far *)cell, 2000, 0, 0, HANDLE);
  }
  exit(0);
}

     VioWrtCharStrAtt(), 㭪 VioWrtNCell()   
न 砫쭮 ப  ⮫  (   砥 0),  
.   ࠭   80 ⮫殢   25  ப   ࠢ 2000.  
  祭   , ᮤঠ饣 ᨬ   ਡ 
.    ।⠢   ᯮ㥬  ᨢ,   ஬
  - ᨬ,  ன - ਡ.

  VioWrtNCell() -  N ⮢ ᨬ - ਡ.
Ŀ
VioWrtNCell(ACell, Times, Row, Column, Handle);           
char far *ACell;       /*  뢠  */ 
unsigned Times;        /* ᫮ 뢠 ⮢ */ 
unsigned Row;          /* ப 砫  */         
unsigned Column;       /* ⮫ 砫  */        
unsigned short Handle; /*  ᥣ 0 */               

     믮 ணࠬ ⨬,     ࠭  
    ᨬ    㣮       ਡ  㣮. 
ணࠬ  API     室     ᢮    ᮡ⢥
ணࠬ אַ 㯠  ࠭ (    MS-DOS.

    室 API - 㭪樨  N ᨬ    
ਡ⮢,    N  ਡ⮢      ᨬ
(⠪    ભ  騩 ⥪,  ਬ).  
஡ ଠ樨 ᬮ ᬮ ࠢ筨 ணࠬ.

                              

	   ந      ᯮ     VIO 㭪権
뢮   ,    ணࠬ 室  䮭 ०.
      拉  砥:  ணࠬ  뫠
饭  START   㣮 ᥠ(session)      ⮢
ணࠬ  筬  ᯮᮡ    ⥬  ४稫   ࠭
㯯.  㤠 ந室 뢮  ⠪ ?

    ᥠ(  ࠭ 㯯)   ᢮  ᮡ⢥ ᪨
,   (LBV). ᫨  , 㭪樮騩   ஬
䮭  ᥠ,      뢮  ⮣       
䨧᪮  ࠭,    ࠭    ᪮    ⮣
ᥠ.   ⥬,         ᥠ     ⠭  ⨢(
짮⥫  室               ᥠᮢ),
ᮤন  LVB  ९뢠    䨧᪨    ᯫ  
⮡ࠦ  ࠭.


                            

    B   OS/2 API   㭪樨  ࠢ   ஬.     
 ⠭      ࠭. ଠ  ⠪  
.  o  ,   ଠ   ᯮ짮  
ணࠬ.    ⮬  ࠧ   ᫥㥬   㭪権 ࠢ-
 ஬.

   饭 
   
    㭪樨  VioSetCurPos()  室  㪠뢠  ⮫쪮  ப   
,  ன    ⠭ .   ⮣ 筮.

       VioSetCurPos() - ⠭ 
Ŀ
    VioSetCurPos(Row,Column,Handle);                             
    unsigned Row;             /*  ப   */             
    unsigned Column;          /*    */             
    unsigned short Handle;    /*  . ᨬ, ᥣ ࠢ 0 */ 


     ࠬ Row  Column -   न 窨,    
   ६饭  .       㭪 ࠢ ०,
ᬮ७  ࠭,  ᠬ    ப    ᠬ  
।  㫥.

      権 ,      ࠧ饭  ,
          ਣ襭     ࠭ 
⥬  짮⥫᪮ . 㭪 VioWrtTTy()   
⮢ ᠬ   ந쭮   ࠭(  ᥣ    
樨 ).  㯯 㭪権  뢮 VioWrtCharStrAttr()  뢮
  ࠭,   ⮬  ६頥 ⥪  .

      ਢ  ணࠬ.    頥  ਣ襭  4-
ࠧ 窠 ࠭  ⥬ 訢  짮⥫  
窥.    窨  ᯮ      ப    । ࠭.
 ࠭ । ᪮ ணࠬ.


/*  curpos.c   */
/* ⠭ pp  */

#define INCL_SUB
#include <os2.h>
#include <stdio.h>
#include <string.h>
#define LENGTH 80                   /*  p   */
#define HANDLE 0                    /* pp p, p 0 */

char s1[] = "Name : ";              /* ᪠      */
char s2[] = "Age : ";
char s3[] = "Heigth: ";
char s4[] = "Weigth: ";

main()
{
 char name[LENGTH];                 /* p   */
 char age[LENGTH];                  /* 짮⥫    */
 char heigth[LENGTH];
 char weigth[LENGTH];

 VioSetCurPos(12, 0, HANDLE);       /* p     */
 VioWrtTTY(s1, strlen(s1),HANDLE);
 gets(name);

 VioSetCurPos(12,40, HANDLE);       /* p  p   */
 VioWrtTTY(s2, strlen(s2),HANDLE);
 gets(age);

 VioSetCurPos(13, 0, HANDLE);       /* p     */
 VioWrtTTY(s3, strlen(s3),HANDLE);
 gets(heigth);

 VioSetCurPos(13,40, HANDLE);       /* p  p   */
 VioWrtTTY(s4, strlen(s4),HANDLE);
 gets(weigth);
 exit(0);
}


   ⮩    ணࠬ     । ࠭ (ப
12, 13)   룫拉 ⠪ :

                 Name : Johann Kepler     Age : 30
                 Heigth : 5'-7"           Weigth : 150


     
   
      ନ    ᪮쪨  ਧ⠫  , 
ਭ   ᨬ.  㬥, 稭  0  孥  .
 ஬   EGA-ନ      13-,  
CGA-ନ - 7-.

    ⢮  ᯮ㥬          ⠭
砫쭮  筮  .    ⮨     
ᨬ쭮 אַ㣮쭨,  ⠪ (  ஬ ᯫ)  砫쭠
 - 12, 筠 - 13.  ᫨  , ⮡    
 אַ㣮쭨, ।  砫   㫥,   -
13-.

         .    ᫨ 
㤥  짮⥫᪨   ⮫쪮 ⢫ .

      ⮩  ணࠬ        ०  
.  ᫨     ᯮ   CGA-,        
ਣ襭 짮⥫   塞  祭   0   7, 
⨢ 砥 -  0  13.


/*  curtype.c   */
/* ⠭ p pp  */

#define INCL_SUB
#include <os2.h>
#include <stdio.h>
#include <string.h>
#define LENGTH 80                   /*  p   */
#define HANDLE 0                    /* pp p, p 0 */

main()
{
 struct _VIOCURSORINFO cursor;
 char string[LENGTH];               /* p           */
                                    /* ⠭  pp  */

 VioGetCurType( &cursor,HANDLE);
                                    /*  砫쭮    */
 printf("p 砫쭮  %d",cursor.yStart);
 printf("  p (0 - 13): ");
 cursor.yStart = atoi(gets(string));
                                    /*  筮     */
 printf("p 筮  %d",cursor.cEnd);
 printf("  p (0 - 13): ");
 cursor.cEnd = atoi(gets(string));
                                    /*    */
 printf("p: %d",cursor.c);
 printf("p %d",cursor.attr);
 printf("pp  (y/n) ? ");
 cursor.attr = atoi(getch() == 'y');  ? -1 : 0;
                                    /*  ⠭ pp */
 VioSetCurType(&cursor, HANDLE);
}


       yStart   End   砫묨  묨
ﬨ.     ⥪⮢  ०     ᥣ  ࠢ   ??  ,⮣  
᪮ - ࠢ  ᥫ, ⠢  ᨬ.᫨
ਡ  attr  ࠢ  1,     㤥  ⠭.    㣮
祭,  㤥 .

     ,        "᪮"    
            .   ।,    ᯮ
EGA-.

c>curtype
 砫쭮  : 12             (0-13) : 13
 筮  : 13              (0-13) : 0
ਭ : 0
ਡ : 0      (y/n) ? n
c>

 ⠪     .

        VioGetCurType - ⥭ ⨯ 
Ŀ
   VioGetCurType(ACurData,Handle);                                 
   struct _VIOCURSORINFO far *ACurData;   /*       */
   unsigned short Handle;        /*  . ᨬ, ᥣ ࠢ 0 */


         VioSetCurType - ⠭ ⨯ 
Ŀ
   VioSetCurType(ACurData);                                        
   struct _VIOCURSORINFO far *ACurData;   /*       */
   unsigned short Handle;        /*  . ᨬ, ᥣ ࠢ 0 */


    ணࠬ ᯮ 㭪  VioGetCurType()  ⥭   
      _VIOURSORINFO,    室 
   .      ⮬   ।   ⥬      
VioSetCurType().

    ᯮ짮 ANSI- ࠢ ஬
    
    ஬ ।⠢ ᮡ⢥ ⥩ ࠢ ஬,
OS/2    ⨢஢  ANSI প ࠢ  ஬  (
㣨  ANSI).   ⠡ ਢ ᯮ㥬 ANSI  
ࠢ ஬.


            ⢨ 

Esc[2j         ⪠ ࠭,  
Esc[K          ⪠   ப
Esc[A          ६     ப
Esc[B          ६     ப
Esc[C          ६  ࠢ   
Esc[D          ६     
Esc[r;cf       ६    ப r,  


 ANSI  稭   ᨬ ESCAPE, 祭   ⠡
"esc".       ᨬ  esc  ।⠢  ᨬ  'x1b'  (筮
祭 27).    ᯨ᮪ ANSI  -  ਢ   㪮⢥ 
⠭  OS/2.     ⠡  㪢  r       楫 ᫠,
⠫ ᨬ ᯮ    ⠡.

      API-   㭪  VioGetAnsi()।   ANSI  -   প
⨢஢  , 㣠 VioSetAnsi()  ⨢஢  
⨢஢  .     ⮩  ணࠬ  ᯮ     㭪樨,
騥  ANSI - ﭨ ᯫ.


/*  setansi.c   */
/* 祭  몫祭 ANSI প  */

#define INCL_SUB
#include <os2.h>
#define HANDLE 0                    /* pp p, p 0 */

main()
{
 unsigned indicator;                /* 0-⨢, 1-⨢  */
 unsigned rc;                       /*              */

                                    /* 뤠 ⥪. ANSI  */

if( rc=VioGetAnsi(&indicator,Handle))
  { printf("VioGetAnsi error=%\n",rc); exit(1);}
printf("Ansi is %s.\n",indicator ? "active" : "not active");
                                    /* ⠭ ANSI   */
printf("Activate or deactivate ansi (a/d) ?");
indicator = (getche()=='a') ? 1 : 0;
if (rc=VioSetAnsi(indicator,Handle))
   {printf("VioSetAnsi error = %u\n",rc); exit(1); }

printf(\n if ansi active, row and col will be accurate");
printf("\x1b[12;40f");
printf(" Row=12, Col=40")
exit(0);
}

    砫 ணࠬ  ᮮ頥 ⥪騩  ANSI -   :  ⨢ 
. ⥬  訢 짮⥫  ,㤥   ᯮ짮 ANSI -
প.   প 㤥  ⨢஢  ᯮ ANSI  -
    ⠭  ,    業  ࠭     ᮮ饭
"Row=12,Column=40".  ᫨   ANSI  ⠭     ন,   
ᮮ饭  ⠥,   ⮬  砥     ᠬ  ANSI ,
   뢠 । ࠩ஬ ANSI ⢨.

      VioGetAnsi -  ANSI 
Ŀ
   VioGetAnsi(AIndicator,Handle);                                   
   unsigned far *AIndicator;     /*               */ 
   unsigned short Handle;        /*  . ᨬ, ᥣ ࠢ 0 */ 



     VioSetAnsi - ⠭ ANSI 
    

Ŀ
   VioSetAnsi(Indicator,Handle);                                    
   unsigned Indicator;           /*   :0-  ⨢,   */ 
                                 /*         1-⨢            */ 
   unsigned short Handle;        /*  . ᨬ, ᥣ ࠢ 0 */ 


    VioGetAnsi()  ᯮ  ⢥ ࠬ  AIndicator,  
 ண ⥬ 頥 . VioSetAnsi() ᯮ
ᮡ⢥ ६  Indicator.祭  ,  ࠢ  0 뢠,
 ANSI প  ⨢,  1 ᫨ ⨢.

    ANSI ESC-     ⠢   ᨬ ப, 
⠥   VioWrtTTy()  㭪樥  printf().

      ᯮ짮  ANSI ESC-᫥⥫쭮 ࠢ ஬
 㤮, 祬  API-㭪樨.

                           

    OS/2 砥  㭪,      ᨬ אַ  
࠭.  ਬ  ணࠬ,  ⠥   ᨬ   孥
 ࠭      .

/* readscr.c */
/* ⠥ ⥪ אַ  ࠭ */
#define INCL_SUB
#include <os2.h>
#define LENGTH 1000  /*   */
#define HALF 12      /*  ࠭ */
#define TOP 0        /* ᠬ  ப */
#define LEFT 0       /* ᠬ 孨 ⮫ */
#define HANDLE 0     /*  ᥣ 0 */
main()
{
  char buffer[LENGTH];
  unsigned length = LENGTH;
  unsigned rc;
                 /* ⠥   ࠭ */
  if( rc=VioReadCharStr(buffer, &length, TOP, LEFT, HANDLE) )
     { printf("VioReadCharStr error=%u\n", rc); exit(1); }
                 /* ८।  */
  VioSetCurPos(HALF, LEFT, HANDLE);
  puts(buffer);  /*     */
  exit(0);
}

    ணࠬ  ᯮ  㭪  VioSetCurPos()  ८।
        ࠭  ᫥  ⥭,  㭪 puts()
⥪   .

         VioReadCharStr() - ⠥ ப ᨬ  ࠭
Ŀ
VioReadCharStr(String, ALength, Row, Column, Handle);          
char far *String;       /*  뢮 ப    */        
unsigned far *ALength;  /*   ப        */        
unsigned Row;           /* ப  砫 ⥭  */        
unsigned Column;        /* ⮫  砫 ⥭ */        
unsigned short Handle;  /*  ᥣ 0            */        

    API -  㭪 VioReadCharStr()  ⠥ ࠭.   ॡ  
뢠  ப  String;      ப,  ALength,   Row 
Column, 㤠 㤥 稭 ⥭.

       ⮬ ਬ, ⥭ த    ࠭,
室   ப   ᫥饩. 㭪     
 ࠭. ᫨ VioReadCharStr() ,   ⥭  ᫨誮
,  ⠭    ࠭  ⠭  ࠬ
length,  ࠢ    ⢨⥫쭮  ⠭  ᨬ ( 祬
㪠뢠  ,   ᠬ ).

                 

      ᭮   ப⪨ ࠭.  묮 ᯮ짮
API - 㭪樨,   VioWrtCharStrAttr(),    ப稢
࠭    宦  .          ᪮쪮
⥪⮢   ࠭.  ᫨     ,  
㦭 ப稢  ⮫쪮   ࠭, ਭ  .  
 ࠭ ப ⥪    ࠭,  ⮬   筠
ப⪠ ࠭ ࠢ     .

    OS/2 API ᮤন  室 㭪樨 ப⪨ -  ப⪨
, ,   ࠢ.  ணࠬ, ᯮ VioScrollUp()
 ப⪨ 쪮  ( 10  25 ᨬ)    ।
࠭.

/* scroll.c */
/* ப稢  ࠭ */
#define INCL_DOS        /*  dossleep() */
#define INCL_SUB        /*  맮 vio */
#include <os2.h>
#define LINES 25        /*  ࠭ */
#define LINE_LENGTH 80  /* ਭ ࠭ */
#define SCR_LENGTH (LINES*LINE_LENGTH)
#define HANDLE 0        /* , ᥣ 0 */
#define HEIGHT 10       /*  쪮  */
                        /* ப  饭   */
char *string[] = { "", "", "", "", "", "",
              "", "ᥬ", "", "" };
main()
{
  unsigned Top = 0;        /*  孨 㣮 ࠭ */
  unsigned Left = 0;
  unsigned Xcell = 0x0758; /* ଠ ਡ, ᨬ 'X' */
  unsigned blank = 0x7020; /* ⨢,  ᨬ */
  unsigned TopRow = 10;    /*   */
  unsigned LeftCol = 24;
  unsigned BotRow = 20;
  unsigned RightCol = 50;
  unsigned lines = 1;        /* ᫮ ப  ப⪨ */
  unsigned char attr = 0x70; /* ਡ ப: ⨢ */
  unsigned rc;               /*   */
  int j;                     /* 稪 横 */

                         /*  ࠭ ᨬ 'X' */
  if( rc=VioWrtNCell( (char far *)&Xcell,
                         SCR_LENGTH, Top, Left, HANDLE ) )
     { printf("VioWrtNCell error=%u", rc); exit(1); }
  for(j=0; j<HEIGHT; j++) {
                         /* ப⪠ 業ࠫ쭮   */
     if( rc=VioScrollUp(TopRow, LeftCol, BotRow, RightCol,
                         lines, (char far *)&blank, HANDLE ) )
        { printf("VioScrollUp error=%u",rc); exit(1); }
                         /*  ப    */
     if( rc=VioWrtCharStr( string[j], strlen(string[j]),
                               BotRow, LeftCol+1, HANDLE ) )
        { printf("VioWrtCharStr error=%u",rc); exit(1); }
     DosSleep(500L);     /* 㧠 */
  }
  exit(0);
}

    砫    頤  ࠭    ᨬ  X  
㭪樨 VioWrtNCell(). ⥬,  横  for,      
 ப,   ப  ப稢    VioScrollUp().  
  ⠥ ப - ᮮ饭, 饥  ᫮ "" 
ࢮ  室  横,  ""  -    ண    ..  
ப⪮  ⠢  প       DosSleep(),   
砥  ப⪨.

    .3-2  뢠,    룫廊  १  ࠡ ணࠬ 
। .

    㭪  VioScrollUp()  ᯮ    ப  設   
㬥 Top   Bottom,      ࠢ  ⮫ -  㬥
Left   Right.   ⠪ 室   Lines,  .. ᪮쪮  ப
ப稢    (  ணࠬ  scroll.c  =  1);    ACell - 
,  ᮤঠ饣    ᨬ  -  ਡ.   ᨬ 
ਡ ᯮ  ப, 塞    ப⪥.

      ணࠬ    ᯮ㥬  楫  ६     
ᨬ, ⠪    ਡ,  ,     ⠪ 來,  
ᯮ짮 2  - ⭮  ᨬ쭮 ᨢ,     ணࠬ
attr.c. (  ⠪ 稭 嫮  ⥬,   ᯮ饩
2 -  楫).

        Ŀ
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        XXXX        XXXXXXXXXXXXXXXXXX
        XXXX         XXXXXXXXXXXXXXXXXX
        XXXX         XXXXXXXXXXXXXXXXXX
        XXXX      XXXXXXXXXXXXXXXXXX
        XXXX        XXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        
         .3-2. 뢮 ணࠬ scroll.c


     VioScrollUp - ப稢 ࠭ 
Ŀ
VioScrollUp(Top, Left, Bottom, Right, Lines, ACell, HANDLE);         
unsigned Top;             /*  ப ப稢 頤*/ 
unsigned Left;            /*  ⮫ ப稢 頤 */ 
unsigned Bottom;          /*  ப ப稢 頤 */ 
unsigned Right;           /* ࠢ ⮫ ப稢 頤*/ 
unsigned Lines;           /* ᫮  ப  ⠢       */ 
unsigned char far *ACell; /*   ᨬ - ਡ */      
unsigned short Handle;    /*  - ᥣ 0 */                     

     ⮩ ணࠬ  ᯮ짮  㭪 -  VioWrtChrStr().
 室  VioWrtCharStrAtt(),  ᬮ७ ࠭,    
   ਡ ᠭ ᨬ.

        VioWrtCharStr -  ப ᨬ
Ŀ
VioWrtCharStr(String, Length, Row, Column, Handle);                  
char far *String;      /*  뢠 ப */               
unsigned Length;       /*  ப              */               
unsigned Row;          /* ப 砫       */               
unsigned Column;       /* ⮫ 砫      */               
unsigned short Handle; /*  ᥣ 0            */               

     ⮬ 砥    㦭  ਡ ᨬ,   ᫨
  ⨬  ᯮ짮  ॢ,  ..  㭪 VioScrollUp() 㦥
⠭ ਡ ப稢 ப.

   㭪樨  ப⪨   ࠭,    ⠪     VioScrollUp(),   ⠪
ᯥ稢 ਢ஢ ⮤  ⪨ ࠭: ᫨  ࠬ
p  Left ⠭  0,  ࠬ Bottom, Right  Lines ࠢ -1
㤥         ᨬ          ਡ⮬,6
⠭묨    ࠬ  Cell.  ᫨  Cell  ।  ᫥騬
ࠧ:

     unsigned Cell = 0x0720;

 ⥬ ᯮ짮 VioScrollUp(0,0,-1,-1,-1,(char far *)&cell,0);
 ࠭ .
    ਬ ᯮ騩  㭪  ᬮਬ .

            

     ⮩ ᥪ樨  ᬮਬ  ਬ ᪮쪨 API 㭪権
 ⢨  ன.

   ⥭ ᨬ  .

   OS/2 ᯥ稢   㭪: KbdCharIn().  㭪 
8쪮 뢠 ASCII   ᨬ,   ᮮ頥  ᪠   
ﭨ     ᬥ饭.  ,   뢠      ,
    BSESUB.H.    뢠 ᫥騬
ࠧ:
struct KBDKEYINFO {
         unsigned char chChar;        /* ASCII  ᨬ         */
         unsigned char chScan;        /* ᪠                   */
         unsigned char fbStatus;      /* প . ⮢    */
         unsigned char bnlsShift;     /* language support shift    */
         unsigned fsStata;            /* ﭨ  ᬥ饭 */
         unsigned Long time;          /* ६                     */
         };


  chChar ६ ᮤন ASCII   ᨬ. ⥬ 砥  
  ᭮  scan  .    ६  chScan,   ⭠
ணࠬ騬    MS  DOS:    ,  㭪樮,
 ࠢ ஬  .  .  ᢮ ᮡ⢥ scan  ,
 ।    . Scan   
      ࠧ祭  ⠭     ࠭ 
⥫쭮 ஢ .    scan   
 । ﭨ  ᬥ饭.

   ६ fbStatus  bNlsShift 易  প 樮
⮢.    㤥   ᬠਢ.

   ६   fsState         ﭨ   ࠧ   
ᬥ饭(shift).   ਢ ⠡ ﭨ  ᬥ饭.

 Ŀ
 8000400020001000800 400 200 10080 40 20 10  8  4  2  1 
 Ĵ
  15  14  13  12  11  10  9   8  7  6  5  4  3  2  1  0 
 
                                                       
[Sys Red] down                                    Right[Shift]
                                                     
 [Caps Look] down                                  Left [Shift]
                                                   
   [Num Look] down                               Either [Ctrl]
                                                 
      [Scroll Look] down                       Either [Alt]
                                               
          8     Right [Alt]                   [Scroll Lock] toggle
                                             
                     Right [Ctrl]          [Num Lock] toggle
                                           
                          Left [Alt]      [Caps Lock] toggle
                                         
                             Left [Ctrl] [Ins] toggle


. 3-3. ⠭ ﭨ ᬥ饭.

     [CTRL]  [ALT]   ﭨ ࠧ  ⮢.  LOCK
 ( NumLock, ScrollLock  . .)  INS  ᯮ  
ਣ   -   ୮      ⨥   뢠   ᬥ  㭪樨  
஢   ᮮ⢥饣   .    ६   Time  뤠
⥬ ६  ᥪ㭤.   稭  ᯮ짮  
। ࢠ  ﬨ  .

    , ਬ  ணࠬ,   ⠥   ᢥ稢 ﭨ
shift      ࠧ  ᫥     ( ஬ ᠬ shift)
.
/* chardata.c */
/* ⠥ ଠ      ⨨ */
#define INCL SUB
#include <os2.h>
#define WAIT 0                  /* wait = 0, no wait =   1 */
#define HANDLE 0                /* kbd handle ᥣ     0 */
#define ESC 27                  /* ASCII  [Esc]  */
main()
{
    struct KBDKEYINFO keydata;  /* ।  subcalls.h */
    unsigned rc;                /*              */

    while(TRUE) {
                                /*  ᨬ     */
        if( rc=KbdCharIn ( &keydata, WAIT, HANDLE) )
           { printf("KbdCharIn error=%u\n",rc); exit(1); }
                                /* print out char data */
        printf("Asii=%u\nScan=%u\nStatus=%x\n",
           keydata.chChar,
           keydata.chScan,
           keydata.fbStatus);
        printf("Dshift=%x\n",
           keydata.bNlsShift,
           keydata.fsState);
        printf("Time (milliseconds) = %ld\n\n", keydata.time);
                               /* check for [Esc] key */
        if( keydata.chChar == ESC )
           exit(0);
   }

}

     ணࠬ 뢠  頥 ଠ   ⮩ .
ਢ ᪮쪮 ਬ஢ ᥠᮢ ࠡ  ணࠬ. ᫥   [a]
  ᫥騩 ⨭:

Ascii=97
Scan=30
Status=40
Dshift=0
Shift=0
Time (milliseconds) = 9491156

᫨  ६    [Ctrl][a],  

Ascii=1
Scan=30
Status=40
Dshift=0
Shift=104
Time (milliseconds) = 95665662

⨥ 㭪樮쭮  [F1] ਢ  ᫥饬 १:

Ascii=0
Scan=59
Status=40
Dshift=0
Shift=0
Time (milliseconds) = 9588718

         ஢     ଠ樨,
ᮤঠ饩       BSESUB.H,           ,
㭪樮쭠 ,  ᬥ饭   .

         KbdCharIn - Read keyboard character data
Ŀ
KbdCharIn(Akeydata, Wait, Handle);                               
struct_KBDKEYINFO far *Akeydata; /*          */    
unsigned Wait; /*  0=wait   ᨬ,1=no wait */    
unsigned short Handle; /* handle ᥣ ࠢ            0 */    


   API 㭪  KbdCharIn() 뢠 ଠ   ᨬ 
  _KBDKEYINFO.   㭪樨      ।     ⮩
    ⢥  ࢮ  㬥:  AKeyData.  㭪  
ࠨ     ࠡ    ०       
  饭  ଠ樨,    ᫨       
ந  .     ⮣  ᯮ  ६ Wait: 
祭 ࠢ 0 ந室   .

    DosSleep(), ᯮ짮 ⮩ 㭪樨  ਢ  
६ CPU - 宫⮩ ࠡ   横,  Wait ࠢ 0.   ⮬
砥  樮  ⥬  ।  ࠢ 㣨 ᠬ 
頥  㭪樨 ⮫쪮 ᫥  ᨬ  .  
ணࠬ  室 ﭭ ஢ ﭨ  .
⬥⨬,     ணࠬ  chardata.c   室   ᠭ
ப   #define  TRUE  1  .    ।  㦥 ᮤন  䠩
OS2DEF.H.    । ⠭ FALSE  . .

      ⥭ ப  .


     API   㭪 KbdStringIn()  뢠 ப   . 
ਢ ਬ ணࠬ, 뢠饩  ப,   짮⥫
 ⥬  뢮 ப  ࠭   VioWrtCharStrAtt() .

/* keystr.c */
/* demonstrates use of KbdStringIn() function */
#define INCL SUB
#include <os2.h>
#define LENGTH 80                 /* length of strihg buffer */
#define WAIT 0                    /* 0=wait, 1=no wait */
#define HANDLE  0                 /* always 0 */
main()
{
    char buffer[LENGHT];          /* buffer for string */
    struct STRINGINBUF lenght;    /* from bsesub.h */
    unsigned char attr = 0x07;    /* normal attribute */
    unsigned space = 0x0720;      /* space, normal attribute */
    unsighed row = 12;            /* set row */
    unsigned column = 0;          /* set column */
    unsigned rc;                  /* return code */
                                  /* clear screen */
    VioScrollUp( 0, 0, -1, -1, -1, (char far *)&space, 0);
    length.cb = LENGTH;           /* set max length */
                                  /* get string from kbd */
    if ( rc=KbdStringIn( buffer, &length, WAIT, HANDLE) )
        { printf("KbdStringIn error=%u", rc); exit(1); }
                                  /* display  string */
    VioWrtCharStrAtt( buffer, length.cchIn, row,
                                      column, &attr, HANDLE);
    exit(0);
}

  ணࠬ ᯮ VioScrollUp()  ⪨ ࠭.  ⮫쪮
짮⥫      ,   짮⥫ ࠧ
⮡ࠦ    ।  ࠭.  㭪  KbdStringIn()  ᯮ
 , ।  BSESUB.H,  ࠭   -
         뢠   ப      ⢠  ᨬ
⢨⥫쭮 ⠭  .   룫廊 ᫥騬
ࠧ:

struct STRINGINBUF {
   unsigned cb;    /*    (255  ᨬ쭮)  */
   unsigned cchIn; /* ᫮ ᨬ ᢨ⥫쭮 ⠭ */
   };

  KbdStringIn() 㭪  3 㬥  筮 Handle.

        KbdStringIn - Read character string from keyboard
Ŀ
KbdStringIn (Buffer, ALength, Wait, Handle);                      
char far *Buffer;      /*    ࠧ饭  */
struct_STRINGINBUF far *ALength; /*               */
unsigned Wait;            /* 0=wait, 1=no wait                  */
unsigned short Handle;    /* handle ᥣ     0                */

   㬥 Buffer  -      ࠧ饭 ப,  ALength -
   ன  ଠ  , ६
Wait  ᨣ  室   ᨬ,  ⮬
:  0 -  , 1 -  .

   ⮣  ᯮ짮 KbdStringIn() 㭪  室 
ࠧ   ࢮ    _STRINGINBUF.   祭
   256. ᫥ 砭 ࠡ 㭪樨  KbdStringIn(),
᫮  ᨬ ᮤন  ஬  .  
᫮ ᯮ 㭪樥 VioWrtCharStrAtt()   ப.

     襬   ਬ     ᯮ짮  ६   wait     
⨢ 楫, ⠪  ⥬ 室  "७" ०.  
⠪ "७" ०  ᬮਬ ᪮쪮 .

    㭪  KbdStringIn()    뢠  ᮪஢ 㭪樥
, ⠪     ࠡ⠥   楫 ப,     ⤥묨
ᨬ.

      C                  

       室   ࠧ ﭨ   ᨬ
 ⮣      ࠬ ⠭. (
ﭨ)    ।  㭪樥  KbdSetStatus().  
ଠ樨, ਬ ଠ  ﭨ  ᬥ饭, 
ଠ 砥 㭪樥 KbdCharIn().

       -  ணࠬ,  ᯮ  KbdGetStatus()  뢠
 .   ᢥ稢   ࠭:
/* kbdstat.c */
/* ।     KbdGetStatus */
#define INCL SUB
#include <os2.h>
#define HANDLE 0               /* ᥣ 0 */
main()
{
     struct KBDINFO keystat;   /* ।  BSESUB.H          */
     unsigned rc;              /*                     */
     unsigned blank = 0x0720;  /* ⥬ ᨬ  ᢥ⫮ 䮭 */

                               /* ⠭       */
     keystat.cb = sizeof(struct_KBDINFO);
                               /*  ࠭                 */
     VioScrollUp( 0, 0, -1, -1, -1, (char far *)&blank, 0);
     while(TRUE)  {            /*         */
        if( rc=KbdGetStatus( &keystat, HANDLE) )
           { printf("KbdGetStatus error=%u\n, rc); exit(1); }
        VioSetCurPos( 10, 0, 0 );      /* cursor at row 10 */
        printf("Mask = %x\n,           keystat.fsMask);
        printf("Turnaround = %x\n,     keystat.chTurnAround);
        printf("Flags = %x\n,          keystat.fsInterim);
        printf("Shift state = %4x\n,   keystat.fsState);
     }
}

      㭪 ᯮ , ।  BSESUB.H. C
 :

struct KBDINFO  {
   unsigned cb;                   /* length of this structure */
   unsigned fsMask;               /* echo, cooked, etc. */
   unsigned chTurnAround;         /* char to end KbdStringIn() */
   unsigned fsInterim;            /* for language support */
   unsigned fsState;              /* state of shift keys */
   };


    ६  cb      ᠬ     , ࠢ 10.
६ fsMask    , 祭     .
3-4.

Ŀ
                                                                   
              0 - ਧ 砭 ப - 1                 
              1 - ਧ 砭 ப - 2                
                                                                   
      \Ŀ               
      /      7   6   5   4   3   2   1   0                
      \               
                               \/     \/                  
 8 - 15                               00 -    
⠭  0                           01 Echo on          
                                          10 Echo off         
                                          11 訡           
                                 00                
                                 01 ன ०                
                                 10 ७ ०             
                                 11 訡                     
                           䨪 ᤢ                   
                       䨪 Interim                       
                    䨪 ਧ 砭                
                                                                   
                                                                   

. 3-4. ᪠  .

         echo-     fsMask  㪠뢠     室
⮡ࠦ    ࠭    ଠ樨.     ஡
ᬮਬ "ன"   "७" ० ࠡ  .    
 室 ᬠਢ 㣨  ᪨.

     KbdGetStatus()     fsMask     ᮮ      ﭨ
.       ᯮ짮   㭪樨   bdSetStatus()   
      ⥬      ᯮ짮
 ࠢ ﭨ .

     ६ chTurnAround   _KBDINFO 筮 ᢠ
祭  [ENTER] (0D hex),     .  
ᨬ ᯮ  ᨣ樨  砭 ப.   ᥣ,
    㤥  ⠭     ६  fsInterim.  fsState -
ᮤন ଠ  ﭨ  ᬥ饭.  ଠ  祭
宦    ଠ,  頥  㭪樥  KbdCharIn().

Ŀ
KbdGetStatus - Gets keyboard status information                    
KbdGetStatus(AStatus, Handle);                                     
struct_KBDINFO far *AStatus;      /*            */   
unsigned short Handle;            /* ᥣ  ࠢ 0          */   


   ஬ Handle,  㬥⮬   㭪樨      AStatus  -   
 _KBDINFO.
    ணࠬ 뢭  ᢥ稢 ଠ  ﭨ 
 ࠭. ᫨    ,  室 ⮪   ᫥騩
:

Mask = 9
Turnaround = d
Flags = 0
Shift state = 0

    祭  Mask      ⮬,    ⠭   (cook)
०, ᨬ 砭   ᨬ  ⪨ (0D
hex). ᫨     ᬥ饭,    
祭 ६ Shift.  砭 ணࠬ ந  ⨥
樨 [Ctrl][c].


                            (raw and cooked modes).

      ࠧ    ७ ०?  O  砥
  ࠢ  ⥭   ᨬ    .    ७   ०,
饬  㬮砭, ⥬    樨
 ࠭  ७ ࠧ.   ਬ,   [Ctrl][c]
筮   뢠   襭    ணࠬ.       [Ctrl][s]
ࠦ   ࠭   뢮      ᫥騩     ᨬ  
ਭ    ᨬ  -     ࠧ蠥 த 뢮 
࠭.

       ஬  ०  ⠪     ந室. 
 [Ctrl][c], ਬ,   뫠 ।⢥   ணࠬ.
       ⮬  砥,     ⠪  樨   室
ᯮ짮  ணࠬ  ᮡ⢥ 㦤.

        -  ணࠬ,    ࠧ稥      
७  ०.      ⠭  ०        㭪樨
KbdSetStatus().

/* raw.c */
/* ⠭  raw/cooked ०   KbdSetStatus() */
#define INCL_SUB
#include <os2.h>
#define HANDLE 0              /* ᥣ 0 */
main()
{
     struct KBDINFO keystat;      /* ᮤন  bsesub.h */
     int j;                       /* 稪 横*/
     unsigned rc;                 /*  e */
                                  /* ⠭   */
     keystat.cb = sizeof(struct_KBDINFO);
                                  /* ।   */
     if( rc=KbdGetStatus( &keystat, HANDLE ) )
        { printf("KbdGetStatus error=%u\n",rc); exit(1);  }
     if( keystat.fsMask & 0x0004 )
        printf("Bit 2 set: raw mode on\n");
     if( keystat.fsMask & 0x0008 )
        printf("Bit 3 set: cooked mode on\n:);
     printf("\nCooked mode on (y/n)? ");
     if( getche() == 'y' ) {
       keystat.fsMask &= 0xFFFB;    /* set bit 2 = 0 */
       keystat.fsMask = 0x0008;    /* set bit 3 = 1 */
    }  else {
       keystat.fsMask = 0x0004;    /* set bit 2 = 1 */
       keystat.fsMask &= 0xFFF7;    /* set bit 3 = 0 */
       }
                                /* 砥   */
       if( rc=KbdSetStatus( &keystat, HANDLE ) )
          { printf("KbdSetStatus error=%u\n",rc); exit(1); }
       for(j=0; j<500; j++)     /* test for cooked */
          printf("%d -- Testing...testing...\n", j);
       exit(0);
}

       ணࠬ  ᭠砫   ।    ,   ⥬
訢 짮⥫   -  ன   ७ ० ⠭.
⠭    ᮮ⢥騥    ०  ,   ,
⠥    横  ᮮ饭,           ६   
짮⥫  ᯥਬ஢    ﬨ  .    ७
०    묨 䥪⠬: প ஫ 
⨨  樨  [Ctrl][s]     砭  ணࠬ     
樨  [Ctrl][c].    ஬  ०   樨  ࠡ 
ணࠬ த  ᮮ饭 "testing...testing".

  KbdSetStatus-Sets keyboard status
Ŀ
KbdSetStatus(AStatus, Handle);                           
struct_KBDINFO far  *AStatus;      /*   */ 
unsigned short Handle;             /* ᥣ        0 */ 

       KbdGetStatus(),  KbdSetStatus()  ,    handle,
ᥣ  㬥, AStatus -  _KBDINFO.

      ᫨   ᬮ ⠭ ணࠬ, ࠡ 
஬  ०:  ᫥    500      ᠬ   ࠡ.
४      ࠭   㯯       祬-
.

                   

        OS/2      ࠡ          ࠧ      ०:
஬ ⥪⮢, CGA  ᪮,CGA ⥪⮢   40  
 ..   ⥬    ,       訢    祭
㤮  -    (  )    -  ᬮ,  
०  ।祭  ⥬ ⠭  ०.

         ⮬  ࠧ   ,   ணࠬ ।,  
० ᯮ   ३  㣮 ०.

          
         

        MS-DOS  ०  ஭㬥஢,         ।
ࠪ⨪: 梥⮢, ⢮  ப     ⥪⮢
०,  ਧ⠫쭠    ⨪쭠  ࠧ  ᯮᮡ   
᪮  ०    ..  㭪樨  OS/2,         
०,         ࠬ   ०,     ࠡ  
ᮡ⢥묨 ࠪ⨪.   ࠧ,   㭪   ⥭
०    VioGetMode()      頥      楫       
ࠪ⨪.    룫廊:


struct  _VIOMODEINFO {
   unsigned length;cb      /*  _VIOMODEINFO  */
   unsigned char fbType;   /* ⮢ ᪠ ࠪ⨪ ० */
   unsigned char color;    /*  ⮢ 梥 */
   unsigned col;           /*  ᨬ  */
   unsigned row;           /*  ᨬ ப */
   unsigned hres;          /* ࠧ ᯮᮡ  ਧ⠫*/
                           /*  ᪮ ० */
   unsigned vres;          /* ࠧ ᯮᮡ  ⨪ */
                           /*  ᪮ ० */
   unsigned char fmt_ID;   /* १,   0*/
   unsigned char attrib;   /* १,   0*/
   };


     ६ cb ᮤন   ᠬ .   
᪮쪮 , ᫨    ᥩ ଠ樨.

     ६ fbType  ࠧ   ⮢ ,   
 .3-5.
      Ŀ
                                                                 
            Ŀ    
              7    6    5    4    3    2    1    0      
                
                                                              
       0=஢  梥⭮ ०  Ĵ                 
       1=஢  梥⭮ ०                   
                                                               
                  0=⮢  ० Ĵ            
                  1=᪨  ०             
                                                                
                   0=஬  ० Ĵ       
                   1=⭮  ०        
                                                                 
      
                                .3-5
                     Type  _VIOMODEINFO .

       color ।祭    梥.

                                 
                           
                             2         1
                             4         2
                             16        4

     Columns  rows   ࠪ⨪ ࠭;  ⨯ 祭:
80   25, 40   25,   80   43,   ᪮  ० hres   vres
 ਧ⠫쭮  ⨪쭮 ࠧ襭 ࠭  ᥫ.

     ᫥    ६    ⮩    १ࢮ,
   ⠭  .

       ਢ  ணࠬ    뢮    ࠭ ᠭ
ଠ.

/* getvio.c */
/* 砥  ᢥ稢  ࠭ ࠬ ० */
#define INCL_SUB
#include <os2.h>
#define  COLOR     0x01              /*  0  ࠬ type */
#define  GRAPHICS  0x02              /*  1  ࠬ type */
#define  NO_BURST  0x04              /*  2  ࠬ type */
#define  HANDLE 0                    /* handle ᥣ 0 */
main( )
{
   struct _VIOMODEINFO modedata;           /*  bsesub.h */

   modedata.cb = sizeof(modedata);         /*   */
   VioGetMode( &modedata, HANDLE );        /* 祭 mode data */
   if( modedata.fbType & COLOR )           /* ⨯  */
     printf("Color adaptor\n");
   else
     printf("Monochrome adaptor\n");
   if( modedata.fbType & GRAPHICS )        /* ⥪⮢ ०  */
                                           /* ᪨         */
      printf("Graphics adapter\n");
   else
      printf("Text mode\n");
   if( modedata.fbType & NO_BURST )        /* ࠧ 梥 */
      printf("Colors burts disabled\n");
   else
      printf("Colors burts enabled\n");
                                           /*  梥 */
   printf("Number of colors bits: %d\n",modedata.color);
                                           /* ࠧ襭 */
   printf("Alpha columns:       %u\n",modedata.col);
   printf("Alpha rows:          %u\n",modedata.row);
   printf("Horiz resolution:    %u\n",modedata.hres);
   printf("Vert resolution:     %u\n",modedata.vres);
   exit(0);
}

         㤥  뤠,    ணࠬ  ࠡ⠥  ⥬ 
᪨ EGA ஬:

Graphics adaptor
Text mode
Color burst enabled
Number of color bits: 4
Alpha columns:     80
Alpha rows:        25
Horiz resolution: 640
Vert resolution:  350
Format ID:         25
Attribute:          0

     ᫨    ᯮ  㣮  ᪨  ०,    ⥬
뤠    ଠ.  ஬  ,  ਬ,   뤠
ࠧ ᯮᮡ 720  350,  㣨 祭.

      VioGetMode - 祭 ଠ樨  ०
 Ŀ
  VioGetMode(AData, Handle);                                     
  struct _VIOMODEINFO far *AData; /*   */         
  unsigned short Handle;          /* ᥣ 0 */                 
 

     㭪樨,  砥 ଠ  ०, VioGetMode(),
ॡ  ⮫쪮   ࠧ饭 ,  ᮤঠ饩 
AData  㪠⥫.

      ⠡ 뢠 騥  OS/2 ०:

Mode       Colors     Resolution      Text          Adaptors
(dec)                 Horiz Vert    Cols Rows    VGA EGA CGA Mono

 0 text   16  grey    320   200     40   25       X   X   X
 0 text   16  grey    320   350     40   43       X   X
 0 text   16  grey    360   400     40   50       X
 1 text   16          320   200     40   50       X   X    X
 1 text   16          320   350     40   43       X   X
 1 text   16          360   400     40   50       X
 2 text   16  grey    640   200     80   25       X   X   X
 2 text   16  grey    640   350     80   43       X   X
 2 text   16  grey    720   400     80   50       X
 3 text   16          640   200     80   50       X   X    X
 3 text   16          640   350     80   43       X   X
 3 text   16          720   400     80   50       X
 4 graph   4          320   200     40   25       X   X    X
 5 graph   2 B&W      320   200     40   25       X   X    X
 6 graph   2 B&W      640   200     80   25       X   X    X
 7 text    2 B&W      720   350     80   25                     X
 7 text    2 B&W      720   400     80   25       X
13 graph  16          320   200     80   25       X   X
14 graph   4          640   200     80   25       X   X
15 graph   2 B&W      640   350     80   25       X   X
16 graph  16          640   350     80   25       X   X
17 graph   2 B&W      640   480     80   30       X
18 graph  16          640   480     80   30       X
19 graph 256          320   200     40   25       X

          ,       騥   ०.
    ०  㣮?


          
         

          ०  ணࠬ,   -,   
_VIOMODEINFO  ᮮ⢥饩  ଠ樥,  ⥬  뢠
VioSetMode()    뫪  ⮩      ⥬.   ଠ,
᫠  ,  ਩   짮⥫, ।⥫쭮
ᯮ짮襣  VioGetMode()    ⠭  㭪権.     ᫥饩
ணࠬ ⠭ ० 楫  짮⥫:

/* setvio.c */
/* sets the video mode */
#define INCL_SUB
#include <os2.h>
#include <stdio.h>                        /*  printf() */
#define COLOR     0x01                    /*  0  ࠬ type */
#define GRAPHICS  0x02                    /*  1  ࠬ type */
#define NO_BURST  0x04                    /*  2  ࠬ type */
#define STRLEN   12
#define HANDLE   0                        /* vio handle ᥣ 0 */
main()
{
   struct _VIOMODEINFO modedata;          /* ᠭ  bsesub.h */
   char string[80];                       /*   */
   unsigned rc;                           /* 頥  */

   modedata.cb =STRLEN                    /* 頥  */
   modedata.fbType &= ~COLOR
   printf("\nMonochrome/color (m/c)?");
   if( getche()=='c')
      modedata.fbTyp |= COLOR;

   modedata.fbTyp &=  ~GRAPHICS;
   printf("\nGraphics or text (g/t)?");
   if( getche()=='g')
      modedata.fbType |=GRAPHICS;

   modedata.fbType &= ~NO_BURST;
   printf("\nColor burts (y/n)?");
   if(getche()=='n')
      modedata.fbType |= NO_BURST;
   printf("\nType parametr = %02x\n",modedata.fbType);
   printf("\nNumber of colors bits: ");
      modedata.color = (char)atoi( gets(string) );
   printf("Number of text columns: ");
      modedata.col = atoi( gets(string) );
   printf("Number of text rows: ");
      modedata.row = atoi( gets(string) );
   printf("Number of horizontal pixels: ");
      modedata.hres = atoi( gets(string) );
   printf("Number of vertical pixels: ");
      modedata.vres = atoi( gets(string) );

   if( rc=VioSetMode( &modedata, HANDLE ) )
      { printf("VioSetMode error=%u\n",rc); exit(1); }
   exit(0);
}

     ணࠬ   砥   ⢥   짮⥫          
ᯮ짮 梥,  ⥪⮢   ᪮ ०   梥⮢
ࠧ , 砥 祭 ᢠ ६ fbType,  
⥬  뢮    ਭ    ନ஢ 짮⥫.㣨
ࠬ  ⠭    ᯮᮡ,  ᫥ 祣 㭪
VioSetMode(), ᯮ ,   ०.  ਬ ࠭  
頥,  ணࠬ  ࠢ  ஬    ⢫    
.

       ਢ  ਬ  ᯮ짮  ணࠬ   ⠭
⥪⮢ ० CGA  ࠪ⨪ 80  25.

Monochrome/color (m/c)? c
Graphics or text (g/t)? t
color burst (y/n) y
tape parameter = 01
Number of color bits: 4
Number of text columns: 80
Number of text rows: 25
Number of horizontal pixels: 640
Number of vertical pixels: 200


     , ᫨     CGA, VGA  ,     ०
ࠡ  43- ப:

Monochrome/color (m/c)? c
Graphics or text (g/t)? t
color burst (y/n) y
tape parameter = 01
Number of color bits: 4
Number of text columns: 80
Number of text rows: 43
Number of horizontal pixels: 640
Number of vertical pixels: 350

     㭪 VioSetMode(), ᯮ VioGetMode(), 砥  ⮫쪮
 ࠬ:  ,  ᮤঠ  ࠪ⨪ ०,
 㪠⥫.

      VioSetMode -   .
 Ŀ
  VioSetMode(AData,Handle);                                       
  struct _VIOMODEINFO far *AData;       /*    */    
  unsigned short Handle;                /* ᥣ 0 */            
 

    _VIOMODEINFO    ⠪  ,    ᯮ㥬    㭪樨
VioGetMode().  ᬠਢ  ࢮ     
, ࠢ 12.  ᫥    ᯮ.

     ᫨  ⠥   ⮩ ணࠬ 㬥,   
ᮮ⢥  ᯮ㥬  㤮,       ᮮ饭:

VioSetMode error=355

          砥  -  "ন  ०  ࠭". ணࠬ
  ஫஢    ,  ।    ।⠢
짮⥫  ᯥ樠쭮  ᮮ饭.,    ,  ணࠬ  
ᮤঠ  ࠬ   ॡ㥬    ०,    筮    ணࠬ
⠭饩  ⥪⮢ CGA ०:

/* setcga.c */
/* sets the video mode to CGA color text, 80 x 25 */
#define INCL_SUB
#include <os2.h>
#define STRLEN   12
#define HANDLE   0                        /* vio handle ᥣ 0 */
main()
{
   struct _VIOMODEINFO modedata;          /* ᠭ  bsesub.h */
   unsigned rc;                           /* 頥  */

   modedata.cb=STRLEN                     /* 頥  */
   modedata.fbType = 0x01;
   modedata.color = 4;
   modedata.col = 80;
   modedata.row = 25;
   modedata.hres = 640;
   modedata.vres = 200;
   if( rc=VioSetMode( &modedata, HANDLE ) )
      { printf("VioSetMode error=%u\n",rc); exit(1); }
   exit(0);
}
     ᯮ  ᯮᮡ,   ⠭   ᪨
०.


             
         

      ணࠬ  㦨  ⮫쪮 ⠭  ᪮
०  設,  ⠪   । ⨯ ⠭  
  ⨯ ᯫ ᮥ  .

     ।⠢  ணࠬ ᮮ   ࠡ⠥    
஬ ०,  CGA, EGA,  VGA       ⨯  ஢
⠭.

/* gconfig.c */
/* gets the video configuration (adapter and display) */
#define INCL_SUB
#inclide <os2.>
#define HANDLE 0
main()
{
   struct _VIOCONFIGINFO config;
   unsigned rc;

   config.cb = sizeof(config);
   if( rc=VioGetConfig( 0, &config, HANDLE ) )
      { printf("VioGetConfig error=%U\n",rc); exit(1); }
   switch(config.adapter)  {
      case 0: printf("Monochrome adaptor\n"); break;
      case 1: printf("CGA adaptor\n"); break;
      case 2: printf("EGA adaptor\n"); break;
      default: printf("Unknown adaptor\n");
      }
   switch(config.display)  {
      case 0: printf("Monochrome display\n"); break;
      case 1: printf("CGA display\n"); break;
      case 2: printf("EGA display\n"); break;
      default: printf("Unknown display\n");
      }
   printf("Display memory size is %u\n", config.cbMemory);
   exit(0);
}

     ⥬  頥  ଠ        ᠭ  
BSESUB.H,  룫廊 ᫥騬 ࠧ:

     struct _VIOCONFIGINFO {
        unsigned cb;
        unsigned adapter;
        unsigned display;
        unsigned long cbMemory;
        };

      adaptor_type  display_type  祭:

		 祭      
                 
		 0            Monochrome
		 1            CGA
		 2            EGA
		 3            VGA

		 祭      ᯫ
                 
		 0            Monochrome
		 1            CGA
		 2            EGA
		 3            VGA

     祭  ६  cbMemory  ࠢ  㬬୮ ࠧ ,
 . 뢮 ᮮ饭  EGA ⥬    㦥
 㤥 룫拉:

EGA adaptor
EGa display
Display memory is 262144 bytes

     ᯮ  ଠ樥     ⨯  ᯫ      ,   
६  ࠪਧ騥  ᯮ㥬  ०,   ணࠬ
  ஡ 㧭    ॡ  ᯫ.

         ଠ樨     䨣樨  ⥬     
_VIOCONFIGINFO ᯮ 㭪 VioGetConfig().

        VioGetConfig -    
 Ŀ
  VioGetConfig(Reserved, Ainfo, Handle);                         
  unsigned Reserved;                                             
  struct _VIOCONFIGINFO far *AInfo;                              
  unsigned short Handle;                                         
 

      㬥  १ࢨ஢      ࠢ .ன
  ᮬ   _VIOCONFIGINFO.⨩ -  㪠⥫
,    ࠢ .

                  P R E S E N T A T I O N    M A N A G E R

     VIO  㭪樨  ᮡ࠭    ᯥ樠    OS/2,  뢠
⥬. 㭪樨  (KBD)   (MOU) ⠪ ଫ  
ᮮ⢥騥                                            ⥬.
   ⥬ -  ⠭ .  , ᫨   ⥬
ᯮ  Presentation  Manager(PM),    VIO,  KBD  MOU ⥬
⫨   ᯮ㥬   OS/2 ᨨ  1.0.    
⭮    ணࠬ.    ⠪  ⠭   ਪ
⥬.

    ⥬  祭 . ,  ࠢ,  
ࠡ    ⠭⭮  䠩  ⥬    㣨   筮
᫮묨  ⥬묨  頬,  ⠪   ८। ⠭
⮪   /뢮       㣨   ਢ묨    楤ࠬ.
  設⢥   砥     室  ਡ     㫮,
ࠪ    MS  DOS,  ⠪   ।⢥  ᨬ
 䨧᪨  ᯫ.

    ᫨  ८। ⠭ ⮪  /뢮
 ,  祬 ᪮.      ᯮ짮   DosRead()  
DosWrite() 㭪樨  䠩 ⥬,     ᬮਬ   
8.    ᠬ   ,  DosRead()     DosWrite()  ᯮ   㭪樨
VioWrtTTY()    KbdStringIn()         ⥭    ⥬   
ந   ७祭    ⠭    ⮪    /뢮.
筮  㭪樨   ⥪  ,   ਬ  printf(),   ⠪   
 ७ ⠭ ⮪.

                           .

   ⠭ 㭪樨   뢮 ᠭ  ⮩ , ࠡ
  ᨬ쭮,        ᪮  ०.    ⮩  稭  
뢠 㭪ﬨ                    . ᪨
㭪樨, 騥  ஢ BIOS MS DOS  ᪠騥 ⥭  
⤥ ᥫ,  ন  OS/2.

  ᫨    ࠡ⠥    OS/2     ।  Presentation  Manager,   
    ⥭        ࠭: 
  㭪権  ᠭ    ᨬ쭮  ०  ᯮ
ப    㭪権   Presentation  Manager.

              ᯮ짮  VIO  㭪樨      PM  ?
PM -    ࠧ   ᫮  । ணࠬ஢,  祬 ⢮
VIO  㭪権  ਪ  䥩(API).   ᫨   ࠧࠡ뢠,
᪠,   ᪨   ⥪⮢   ,          
६    祭  ਥ  ணࠬ஢   । Presentation
Manager.       ,      ஬ ਫ  ⮬ 
室.    ணࠬ     ॡ  ࣠樨
䥩 ஢  PM, ਬ,  ணࠬ ஢   
㫥.       ணࠬ,  騥    ᮪
 ⮨,   ⮬     ᫠ ࠧࠡ뢠 
  㯭⠡     䥩;      筮
࣠   ⢨      ᨬ쭮   ०.   ਫ,
ᠭ  ᨬ쭮 ०  ⫨筮 ࠡ  ।  Presentation
Manager.      ⮫쪮 ᯮ짮 ணࠬ  ᪮
䥩, ஥  PM.

                              

     ⮩   ᬮ५  API 㭪権,  믮
 樨 ⢨  ࠭  ன.

     㢨,  ந室   䨪஢  ࠭ 
묨  ਡ⠬,  ᯮ  VioWrtCharStrAttr(),   ࠧ
ଠ                  VioWrtTTy()    
࣠뢠    饩  ᫥⥫쭮  ᨬ  
 VioWrtNCell().

           VioSetCurPos()  ⨯
   ।  ⠭    VioGetCurType()
   VioSetCurType()   ᮮ⢥⢥.  ᯮ 㭪樨  VioGetAnsi()
 VioSetAnsi()    । , ⠭   몫
ANSI  ࠩ  ࠭    .   ப  ᨬ 뢠 
  ࠭ 㭪樥 VioReadCharStr().  ᬮ ଠ樨
  ࣠뢠    4  API 㭪権 ப⪨,   
 VioScrollUp().

    ,      ஡       ଠ樥, 뢠 
 㭪樥   KbdCharIn(), ப  -    KbdStringIn().
ﭨ    ᬥ饭(shift)    㣠  ଠ  
뢠  㭪樥     KbdGetStatus()    ⠭   㭪樥
KbdSetStatus().   ,   ,     ᬮ५  ᯮᮡ   祭
ଠ樨  ० 㭪樥  VioSetMode().

          뫮  ९  몮   
⨫ ᯮ짮 API  㭪権.    ⮢ 筮,
⮡ 㯨     ᠬ   ᮡ OS/2  -
筮.