etgri_b.cpp

its creates virtual multi tasking i DOS

/*******************************************************
 *                                                     *
 *  Program : EasyTask        Language : C++           *
 *                                                     *
 *  Modified : 20 nov 2003                             *
 *                                                     *
 *  Copyright (c) 1988,2003, ORITECH    V 5.1          *
 *  All rights reserved.                               *
 *                                                     *
 *******************************************************
 *  You may not give away or cell or copy any part of  *
 *  the source code.                                   *
 *******************************************************
 *                                                     *
 *  MTGRI_B.CPP graphic interface functions (BORLAND)  *
 *                                                     *
 *******************************************************/

#define etgri_b_cpp

#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <string.h>
#include <malloc.h>
#include <conio.h>
#ifdef __BORLANDC__
  #include <graphics.h>   
#else  // MSVC
  #include <graph.h>   
  #include <time.h>    
#endif
#include <ctype.h>
#include "etker.h"
#include "etgri_b.h"

//////////////////////////////////////////////////////////////////
// define TSetOfChar functions

BOOL SetIn(TSetOfChar set, byte n)
{
  return ((BOOL)((set[n/16] >> (n%16)) & 1));
}

BOOL SetNull(TSetOfChar set)
{
  word x;
  byte n;
  
  x = 0;
  for (n=0; n<=15; n++)
    x |= set[n];
  if (x == 0) return TRUE;
  else return FALSE;
}

void SetClear(TSetOfChar set)
{
  byte n;
  
  for (n=0; n<=15; n++)
    set[n] = 0;
}

void SetOn(TSetOfChar set, byte n)
{
  set[n/16] |= (short)(1 << (n%16));
}

void SetOff(TSetOfChar set, byte n)
{
  set[n/16] &= (short)(~(1 << (n%16)));
}

void SetRangeOn(TSetOfChar set, byte n1, byte n2)
{
  byte n;

  for (n=n1; n<=n2; n++)
    seton(set,n);
}

void SetRangeOff(TSetOfChar set, byte n1, byte n2)
{
  byte n;
  
  for (n=n1; n<=n2; n++)
    setoff(set,n);
}

void SetAdd(TSetOfChar set, const TSetOfChar set2)
{
  byte n;
  
  for (n=0; n<=15; n++)
    set[n] = set[n] | set2[n];
}

void SetSub(TSetOfChar set, const TSetOfChar set2)
{
  byte n;
  
  for (n=0; n<=15; n++)
    set[n] = (short)(set[n] & (~set2[n]));
}

void SetCopy(TSetOfChar set, const TSetOfChar set2)
{
  byte n;
  
  for (n=0; n<=15; n++)
    set[n] = set2[n];
}

// End: define TSetOfChar functions
//////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////
// define graphic functions

void AReadKey(BOOL *keyfunc, char *keychar, BOOL upper)
{
  int c;
  BOOL cr;
  long t;
  int col,bkcol;
  struct textsettingstype ts;
  
  t = TickCount();
  if ((*currenttask)->modepause == MTG)
  {
    gettextsettings(&ts);
    col = getcolor();
    bkcol = getbkcolor();
  }
  cr = FALSE;
  if ((*currenttask)->modepause == MTT)
    cprintf("%c%c",95,8);
  if ((*currenttask)->modepause == MTG)
  {
    setcolor(col);
    outtext("_");
    if (ts.direction == 0)
      moverel(-textwidth("_"),0);
    else
      moverel(0,-textwidth("_"));
    setcolor(col);
  }
  do
  {
    Pause();
    if ((*currenttask)->modepause == MTT)
    {
      if (tickcount() - t >= 500)
      {
        t = tickcount();
        if (cr)
        {
          cprintf("%c%c",95,8);
          cr = FALSE;
        }
        else
        {
          cprintf("%c%c",32,8);
          cr = TRUE;
        }
      }
    }
    if ((*currenttask)->modepause == MTG)
    {
      if (tickcount() - t >= 500)
      {
        t = tickcount();
        if (cr)
        {
          setcolor(col);
          outtext("_");
          if (ts.direction == 0)
            moverel(-textwidth("_"),0);
          else
            moverel(0,-textwidth("_"));
          cr = FALSE;
        }
        else
        {
          setcolor(bkcol);
          outtext("_");
          if (ts.direction == 0)
            moverel(-textwidth("_"),0);
          else
            moverel(0,-textwidth("_"));
          cr = TRUE;
        }
      }
    }
  } while (!kbhit());
  if ((*currenttask)->modepause == MTT)
    cprintf("%c%c",32,8);
  if ((*currenttask)->modepause == MTG)
  {
    setcolor(bkcol);
    outtext("_");
    if (ts.direction == 0)
      moverel(-textwidth("_"),0);
    else
      moverel(0,-textwidth("_"));
    setcolor(col);
  }
  c = getch();
  if (c != '\0')
  {
    *keyfunc = FALSE;
    if (upper)
      c = toupper(c);
  }
  else
  {
    *keyfunc = TRUE;
    c = getch();
  }
  *keychar = (char)c;
}

void AReadKeyMask(BOOL *keyfunc, char *keychar, BOOL upper,
                  const TSetOfChar mask, const TSetOfChar maskfunc)
{
  BOOL fin;
  TSetOfChar mask_, maskfunc_;
  
  setcopy(mask_,mask);
  setcopy(maskfunc_,maskfunc);
  /**/
  fin = FALSE;
  do
  {
    AReadKey(keyfunc,keychar,upper);
    if (*keyfunc)
    {
      if (setin(maskfunc_,*keychar))
      fin = TRUE;
    }
    else
    {
      if (setin(mask_,*keychar) || (setnull(mask_)))
      fin = TRUE;
    }
  } while (!fin);
}

void TInquire(char *s, byte len, BOOL upper, const TSetOfChar mask,
              const TSetOfChar maskquitfunc, const TSetOfChar maskquit,
              BOOL quitbol, BOOL quiteol, byte *quitmode, char *quitchar)
{
  BOOL fin;
  BOOL cf;
  unsigned char c;
  char cs[2] = {0,0};
  TSetOfChar kmask;
  TSetOfChar mask_, maskquitfunc_, maskquit_;
  
  setcopy(mask_,mask);
  setcopy(maskquitfunc_,maskquitfunc);
  setcopy(maskquit_,maskquit);
  /**/
  setclear(kmask);
  setadd(kmask,mask_);
  setadd(kmask,maskquit_);
  *quitmode = 0;
  *quitchar = '\0';
  cprintf("%s",s);
  fin = FALSE;
  do
  {
    AReadKeyMask(&cf,(char *)&c,upper,kmask,maskquitfunc_);
    if (!cf)  /* char normal */
    {
      if (setin(maskquit_,c))
      {
        *quitmode = IQQUIT;
        *quitchar = c;
        fin = TRUE;
      }
      if (c == '\b')  /* del char <- */
      {
        if (s[0] != 0)
        {
          cprintf("%c %c",8,8);
          s[strlen(s)-1] = '\0';
        }
        else  /* length(s) == 0 */
        {
          if (quitbol)
          {
            fin = TRUE;
            *quitmode = IQBOL;
          }
        }
      }
      else  /* char for disp */
      {
        if ((strlen(s) < len) && ((c>=' ') && (127>=c)))
        {
          cs[0] = c;
          strcat(s,cs);
          putch(c);
        }
      }
    }
    else  /* code func */
    {
      fin = TRUE;
      *quitmode = IQFUNC;
      *quitchar = c;
    }
    if ((strlen(s) >= len) && quiteol)
    {
      fin = TRUE;
      *quitmode = IQEOL;
    }
  } while (!fin);
}

void GInquire(char *s, byte len, BOOL upper, const TSetOfChar mask,
              const TSetOfChar maskquitfunc, const TSetOfChar maskquit,
              BOOL quitbol, BOOL quiteol, byte *quitmode, char *quitchar)
{
  BOOL fin;
  BOOL cf;
  unsigned char c;
  char cs[2] = {0,0};
  struct textsettingstype ts;
  int col;
  int bkcol;
  TSetOfChar kmask;
  TSetOfChar mask_, maskquitfunc_, maskquit_;
  
  setcopy(mask_,mask);
  setcopy(maskquitfunc_,maskquitfunc);
  setcopy(maskquit_,maskquit);
  /**/
  gettextsettings(&ts);
  col = getcolor();
  bkcol = getbkcolor();
  setclear(kmask);
  setadd(kmask,mask_);
  setadd(kmask,maskquit_);
  *quitmode = 0;
  *quitchar = '\0';
  outtext(s);
  fin = FALSE;
  do
  {
    AReadKeyMask(&cf,(char *)&c,upper,kmask,maskquitfunc_);
    if (!cf)  /* char normal */
    {
      if (setin(maskquit_,c))
      {
        *quitmode = IQQUIT;
        *quitchar = c;
        fin = TRUE;
      }
      if (c == '\b')  /* del char <- */
      {
        if (strlen(s) > 0)
        {
          cs[0] = s[strlen(s)-1];
          if (ts.direction == 0)
            moverel(-(textwidth(cs)),0);
          else
            moverel(0,-(textwidth(cs)));
          setcolor(bkcol);
          outtext(cs);
          setcolor(col);
          if (ts.direction == 0)
            moverel(-(textwidth(cs)),0);
          else
            moverel(0,-(textwidth(cs)));
          s[strlen(s)-1] = '\0';
        }
        else  /* length(s) == 0 */
        {
          if (quitbol)
          {
            fin = TRUE;
            *quitmode = IQBOL;
          }
        }
      }
      else  /* char for disp */
      {
        if ((strlen(s) < len) && ((c>=' ') && (127>=c)))
        {
          cs[0] = c;
          strcat(s,cs);
          outtext(cs);
        }
      }
    }
    else  /* code func */
    {
      fin = TRUE;
      *quitmode = IQFUNC;
      *quitchar = c;
    }
    if ((strlen(s) >= len) && quiteol)
    {
      fin = TRUE;
      *quitmode = IQEOL;
    }
  } while (!fin);  /* clear cursor */
}

void Inquire(char *s, byte len, BOOL upper, const TSetOfChar mask,
             const TSetOfChar maskquitfunc, const TSetOfChar maskquit, BOOL quitbol,
             BOOL quiteol, byte *quitmode, char *quitchar)
{
  TSetOfChar mask_, maskquitfunc_, maskquit_;
  
  setcopy(mask_,mask);
  setcopy(maskquitfunc_,maskquitfunc);
  setcopy(maskquit_,maskquit);
  //
  switch ((*currenttask)->modepause)
  {
    case MTN:
      TInquire(s,len,upper,mask_,maskquitfunc_,maskquit_,quitbol,quiteol,
               quitmode,quitchar);
      break;
    case MTT:
      TInquire(s,len,upper,mask_,maskquitfunc_,maskquit_,quitbol,quiteol,
               quitmode,quitchar);
      break;
    case MTG:
      GInquire(s,len,upper,mask_,maskquitfunc_,maskquit_,quitbol,quiteol,
               quitmode,quitchar);
      break;
    default:
      TInquire(s,len,upper,mask_,maskquitfunc_,maskquit_,quitbol,quiteol,
               quitmode,quitchar);
      break;
  }
}

void MTRead(char *s)
{
  byte quitmode;
  char quitchar;
  TSetOfChar mask;
  TSetOfChar maskquitfunc;
  TSetOfChar maskquit;
  
  setclear(mask);
  setrangeon(mask,0,255);
  setclear(maskquitfunc);
  setclear(maskquit);
  seton(maskquit,'\r');
  inquire(s,255,FALSE,mask,maskquitfunc,maskquit,
    FALSE,FALSE,&quitmode,&quitchar);
}

long MTReadInt(char **error)
{
  long r_mtreadint;
  byte quitmode;
  char quitchar;
  char s[64];
  long i;
  TSetOfChar mask;
  TSetOfChar maskquitfunc;
  TSetOfChar maskquit;  
  
  strcpy(s,"");
  setclear(mask);
  seton(mask,'\r');
  setrangeon(mask,'0','9');
  seton(mask,'+');
  seton(mask,'-');
  seton(mask,'.');
  seton(mask,8);
  setclear(maskquitfunc);
  setclear(maskquit);
  seton(maskquit,'\r');
  Inquire(s,255,FALSE,mask,maskquitfunc,maskquit,FALSE,FALSE,&quitmode,&quitchar);
  i = strtol(s,error,10);
  r_mtreadint = i;
  return r_mtreadint;
}

double MTReadReal(char **error)
{
  double r_mtreadreal;
  byte quitmode;
  char quitchar;
  char s[80];
  double i;
  TSetOfChar mask;
  TSetOfChar maskquitfunc;
  TSetOfChar maskquit;  
  
  strcpy(s,"");
  setclear(mask);
  seton(mask,'\r');
  setrangeon(mask,'0','9');
  seton(mask,'+');
  seton(mask,'-');
  seton(mask,'.');
  seton(mask,'e');
  seton(mask,'E');
  seton(mask,8);
  setclear(maskquitfunc);
  setclear(maskquit);
  seton(maskquit,'\r');
  Inquire(s,255,FALSE,mask,maskquitfunc,maskquit,FALSE,FALSE,&quitmode,&quitchar);
  i = strtod(s,error);
  r_mtreadreal = i;
  return r_mtreadreal;
}

#ifndef _WIN32
void AWriteTextFileToLst(char *fname, BOOL modechar, BOOL *stop)
{
  FILE *f;
  char s[256];
  int n;
  
  n = modechar;
  f = fopen(fname,"r");
  if (f == NULL)
    return;
  Pause();
  while ((!feof(f)) && (!*stop))
  {
    fgets(s,256,f);
    n = strlen(s);
    s[n] = 13;
    s[n+1] = 10;
    s[n+2] = 0;
    awritetolst(s);
  }
  fclose(f);
}

void AWriteToLst(char *s)
{
  int n;
  int stat;
  int flag;
  union REGS regs;
  
  for (n=0; s[n]>0; n++)
  {
    do
    {
      regs.h.ah = 0x02;
      regs.h.al = 0;
      regs.x.dx = 0;
      int86(0x17,&regs,&regs);
      flag = 0;
      stat = regs.h.ah;
      if (
        ((stat & 16) == 16) /* on line == 1 */
        && (((~ stat) & 32) == 32) /* not paper == 0 */
        && ((stat & 128) == 128) /* printing == 1 */
        ) flag = 1;
      if (flag == 0) Pause();
    } while (flag == 0); /* char ready, printer ok */
    regs.x.ax = s[n];
    regs.x.dx = 0; /* printer number */
    int86(0x17,&regs,&regs);
  }
  Pause();
}
#endif
   
void PauseMode(byte mode)
{
  switch(mode)
  {
    case MTN:
      (*currenttask)->pauseproc = NPause;
      break;
    case MTT:
      (*currenttask)->pauseproc = TPause;
      break;
    case MTG:
      (*currenttask)->pauseproc = GPause;
      break;
    default:
      (*currenttask)->pauseproc = NPause;
      break;
  }
  (*currenttask)->modepause = mode;
}

void TPause(void)
{
  struct text_info inforec;
  
  gettextinfo(&inforec);
  NPause();
  textattr(inforec.attribute);
  window(inforec.winleft,
         inforec.wintop,
         inforec.winright,
         inforec.winbottom);
  gotoxy(inforec.curx,inforec.cury);
}

void GPause(void)
{
  struct viewporttype vp;
  int gc;
  struct fillsettingstype gfs;
  struct textsettingstype tst;
  struct linesettingstype lst;
  int gx;
  int gy;
  
  gc = getcolor();
  getviewsettings(&vp);
  getfillsettings(&gfs);
  gettextsettings(&tst);
  getlinesettings(&lst);
  gx = getx();
  gy = gety();
  NPause();
  setviewport(vp.left,vp.top,vp.right,vp.bottom,vp.clip);
  setcolor(gc);
  setfillstyle(gfs.pattern,gfs.color);
#ifndef _WIN32
  settextstyle(tst.font,tst.direction,tst.charsize);
#endif
  settextjustify(tst.horiz,tst.vert);
  setlinestyle(lst.linestyle,lst.upattern,lst.thickness);
  moveto(gx,gy);
}
                                     
// End: define graphic functions
//////////////////////////////////////////////////////////////////

// *** end of file ***